初识JUC

一、什么是JUC

JUC是java.util .concurrent包的简称，这是一个处理线程的工具包。

二、进程和线程

2.1 进程和线程

Java默认有两个线程，main和GC这两个线程

Java真的可以开启线程么？

Java本身没权权限开启线程，通过start()的源码可知，调用了本地方法，即调用了底层的C++

public synchronized void start() {
          
   
        /**
         * This method is not invoked for the main method thread or "system"
         * group threads created/set up by the VM. Any new functionality added
         * to this method in the future may have to also be added to the VM.
         *
         * A zero status value corresponds to state "NEW".
         */
        if (threadStatus != 0)
            throw new IllegalThreadStateException();

        /* Notify the group that this thread is about to be started
         * so that it can be added to the groups list of threads
         * and the groups unstarted count can be decremented. */
        group.add(this);

        boolean started = false;
        try {
          
   
            start0();
            started = true;
        } finally {
          
   
            try {
          
   
                if (!started) {
          
   
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
          
   
                /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
            }
        }
    }
	//native为本地方法，调用底层的C++，Java运行在虚拟机上，无法调用硬件
    private native void start0();

2.2 并行和并发

并发(多个线程同时操作同一个资源) 如果CPU只有一核，一次只能处理一条指令，通过快速切换虚拟出多条线程实现并发。 并行（多个人一起行走）: 并行提高效率，采用线程池 CPU多核，多个线程可以同时执行 如何获取系统CPU的核数：

public class Test1 {
          
   
    public static void main(String[] args) {
          
   
        //获取cpu核数
        //CPU密集型，IO密集型
        System.out.println(Runtime.getRuntime().availableProcessors());
    }
}

并发编程的本质：充分利用CPU的资源 为什么要并发编程：CPU/内存/IO设备的速度有极大差异,为了合理利用CPU的高性能,操作系统增加了进程/线程.

2.3 Java线程有几个状态

通过源码可以知道线程有六个状态

Thread.State.NEW;
public enum State {
          
   
        /**
         * Thread state for a thread which has not yet started.
         */
        NEW,		//线程新生
        RUNNABLE,	//线程运行
        BLOCKED,	//线程阻塞
        WAITING,	//等待，死死的等待
        TIMED_WAITING,	//超时等待
        TERMINATED;		//终止
}

2.4 wait/sleep的区别

来自不同的类 wait ==> Object sleep ==> Thread 关于锁的释放 wait会释放锁，sleep睡着了，抱着锁睡觉，不会释放锁 使用的范围不同 wait：必须在同步代码块中使用，必须又可以等待的对象 sleep：任何时候都可以睡 是否需要捕获异常 wait 不需要捕获异常; sleep需要捕获异常InterruptedException(属于checked exception：指的是编译时异常)，进程在休眠的过程中不可被打断，被打断则抛出异常。

public static void main(String[] args){
          
   
        Thread a = new Thread(){
          
   
            @Override
            public void run(){
          
   
                try {
          
   
                    System.out.println("正在执行线程");
                    Thread.sleep(10000);
                } catch (InterruptedException e) {
          
   
                    e.printStackTrace();
                    System.out.println("休眠的进程被打断");
                }
            }
        };
        a.start();
        a.interrupt();
    }

正在执行线程 休眠的进程被打断 java.lang.InterruptedException: sleep interrupted at java.lang.Thread.sleep(Native Method) at gdut.hzh.demo01.Test1$1.run(Test1.java:17)