JUC并发编程入门学习笔记（狂神说）

目录

1. 什么是JUC

2. 线程和进程

1）进程

2）线程

3）并发

4）并行

5）线程的状态

6）wait/sleep

3.Lock

1）传统的 synchronized

2）Lock

3).Synchronized 与Lock 的区别

4. 生产者和消费者的关系

1）Synchronzied 版本

2）JUC版本的生产者和消费者问题

5、6锁现象

6、不安全的集合类

HashSet底层是什么？

7、Callable

 8、常用的辅助类(必会！)

8.1 CountDownLatch​

8.2 CyclickBarrier

8.3 Semaphore

9、读写锁

 10、阻塞队列

BlockingQueue

如何使用阻塞队列呢？

SynchronousQueue同步队列

11、线程池(重点)

12、四大函数式接口（必需掌握）

13、Stream流式计算

14、ForkJoin

15、异步回调

（1）没有返回值的runAsync异步回调

 （2）有返回值的异步回调supplyAsync

16.深入理解CAS

17、原子引用

18. 各种锁的理解

1、公平锁、非公平锁

2、可重入锁

3.自旋锁

4.死锁

---

因为热爱所以坚持，因为热爱所以等待。熬过漫长无戏可演的日子，终于换来了人生的春天，共勉！！！

1. 什么是JUC

JUC就是java.util.concurrent下面的类包，专门用于多线程的开发。

2. 线程和进程

进程是操作系统中的应用程序、是资源分配的基本单位，线程是用来执行具体的任务和功能，是CPU调度和分派的最小单位

一个进程往往可以包含多个线程，至少包含一个

1）进程

一个程序，QQ.EXE Music.EXE；数据+代码+pcb

一个进程可以包含多个线程，至少包含一个线程！

Java默认有几个线程？2个线程！ main线程、GC线程

2）线程

开了一个进程Typora，写字，等待几分钟会进行自动保存(线程负责的)

对于Java而言：Thread、Runable、Callable进行开启线程的。

提问？JAVA真的可以开启线程吗？ 开不了的！

Java是没有权限去开启线程、操作硬件的，这是一个native的一个本地方法，它调用的底层的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 group's list of threads
         * and the group's 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 */
            }
        }
    }
	//这是一个C++底层，Java是没有权限操作底层硬件的
    private native void start0();

3）并发

多线程操作同一个资源。

• CPU 只有一核，模拟出来多条线程，天下武功，唯快不破。那么我们就可以使用CPU快速交替，来模拟多线程。
• 并发编程的本质：充分利用CPU的资源！

4）并行

• CPU多核，多个线程可以同时执行。 我们可以使用线程池！

获取cpu的核数

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

5）线程的状态

Thread类中有个内部枚举，可以看到六种状态

public enum State {
        /**
         * Thread state for a thread which has not yet started.
         */
    	//运行
        NEW,

        /**
         * Thread state for a runnable thread.  A thread in the runnable
         * state is executing in the Java virtual machine but it may
         * be waiting for other resources from the operating system
         * such as processor.
         */
    	//运行
        RUNNABLE,

        /**
         * Thread state for a thread blocked waiting for a monitor lock.
         * A thread in the blocked state is waiting for a monitor lock
         * to enter a synchronized block/method or
         * reenter a synchronized block/method after calling
         * {@link Object#wait() Object.wait}.
         */
    	//阻塞
        BLOCKED,

        /**
         * Thread state for a waiting thread.
         * A thread is in the waiting state due to calling one of the
         * following methods:
         * 

         *   
{@link Object#wait() Object.wait} with no timeout
         *   
{@link #join() Thread.join} with no timeout
         *   
{@link LockSupport#park() LockSupport.park}
         * 
         *
         * 
A thread in the waiting state is waiting for another thread to
         * perform a particular action.
         *
         * For example, a thread that has called Object.wait()
         * on an object is waiting for another thread to call
         * Object.notify() or Object.notifyAll() on
         * that object. A thread that has called Thread.join()
         * is waiting for a specified thread to terminate.
         */
    	//等待
        WAITING,

        /**
         * Thread state for a waiting thread with a specified waiting time.
         * A thread is in the timed waiting state due to calling one of
         * the following methods with a specified positive waiting time:
         * 

         *   
{@link #sleep Thread.sleep}
         *   
{@link Object#wait(long) Object.wait} with timeout
         *   
{@link #join(long) Thread.join} with timeout
         *   
{@link LockSupport#parkNanos LockSupport.parkNanos}
         *   
{@link LockSupport#parkUntil LockSupport.parkUntil}
         * 
         */
    	//超时等待
        TIMED_WAITING,

        /**
         * Thread state for a terminated thread.
         * The thread has completed execution.
         */
    	//终止
        TERMINATED;
    }

6）wait/sleep

1、来自不同的类

wait => Object

sleep => Thread

一般情况企业中使用休眠是：

TimeUnit.DAYS.sleep(1); //休眠1天
TimeUnit.SECONDS.sleep(1); //休眠1s

2、关于锁的释放

wait 会释放锁；

sleep睡觉了，不会释放锁；

3、使用的范围是不同的

wait 必须在同步代码块中；

sleep 可以在任何地方睡；

4、是否需要捕获异常

wait必须要捕获异常；

sleep必须要捕获异常；

3.Lock

1）传统的 synchronized

2）Lock

 

公平锁： 十分公平，必须先来后到~；

非公平锁： 十分不公平，可以插队；(默认为非公平锁)

3).Synchronized 与Lock 的区别

1、Synchronized 内置的Java关键字，Lock是一个Java类

2、Synchronized 无法判断获取锁的状态，Lock可以判断

3、Synchronized 会自动释放锁，lock必须要手动加锁和手动释放锁！可能会遇到死锁

4、Synchronized 线程1(获得锁->阻塞)、线程2(等待)；lock就不一定会一直等待下去，lock会有一个trylock去尝试获取锁，不会造成长久的等待。

5、Synchronized 是可重入锁，不可以中断的，非公平的；Lock，可重入的，可以判断锁，可以自己设置公平锁和非公平锁；

4. 生产者和消费者的关系

1）Synchronzied 版本

public class A {
    public static void main(String[] args) {
        Data data = new Data();

        new Thread(()->{for(int i=0;i<10;i++) {
            try {
                data.increment();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        },"A").start();
        new Thread(()->{for(int i=0;i<10;i++) {
            try {
                data.decrement();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }},"B").start();
    }
}
class Data{
    //数字  资源类
    private int number = 0;

    //+1
    public synchronized void increment() throws InterruptedException {
        if(number!=0){
            //等待操作
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知其他线程 我+1完毕了
        this.notifyAll();
    }

    //-1
    public synchronized void decrement() throws InterruptedException {
        if(number==0){
            //等待操作
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知其他线程  我-1完毕了
        this.notifyAll();
    }

}

结果:实现A,B之间的生产者消费者问题

 但是存在一个问题，现在是A，B连两个线程，现在如果我有四个线程A B C D！

public class A {
    public static void main(String[] args) {
        Data data = new Data();
        
        new Thread(()->{
        for(int i=0;i<10;i++) {
            try {
                data.increment();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        
        },"A").start();
        new Thread(()->{for(int i=0;i<10;i++) {
            try {
                data.decrement();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }},"B").start();
        
        new Thread(()->{for(int i=0;i<10;i++) {
            try {
                data.increment();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }},"C").start();
        
        new Thread(()->{for(int i=0;i<10;i++) {
            try {
                data.decrement();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }},"D").start();
    }
}
class Data{
    //数字  资源类
    private int number = 0;

    //+1
    public synchronized void increment() throws InterruptedException {
        if(number!=0){
            //等待操作
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知其他线程 我+1完毕了
        this.notifyAll();
    }

    //-1
    public synchronized void decrement() throws InterruptedException {
        if(number==0){
            //等待操作
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知其他线程  我-1完毕了
        this.notifyAll();
    }

}

结果：出现错误

解决方案： if 改为while即可，防止虚假唤醒

这样就不存在问题了：

public class A {
    public static void main(String[] args) {
        Data data = new Data();
        
        new Thread(()->{
        for(int i=0;i<10;i++) {
            try {
                data.increment();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        
        },"A").start();
        new Thread(()->{for(int i=0;i<10;i++) {
            try {
                data.decrement();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }},"B").start();
        
        new Thread(()->{for(int i=0;i<10;i++) {
            try {
                data.increment();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }},"C").start();
        
        new Thread(()->{for(int i=0;i<10;i++) {
            try {
                data.decrement();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }},"D").start();
    }
}
class Data{
    //数字  资源类
    private int number = 0;

    //+1
    public synchronized void increment() throws InterruptedException {
        while(number!=0){ //if改成while
            //等待操作
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知其他线程 我+1完毕了
        this.notifyAll();
    }

    //-1
    public synchronized void decrement() throws InterruptedException {
        while(number==0){ //if改成while
            //等待操作
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知其他线程  我-1完毕了
        this.notifyAll();
    }

}

结果：成功实现四个线程互斥

2）JUC版本的生产者和消费者问题

await、signal 替换 wait、notify

 

public class B {
	public static void main(String[] args) {
		Data2 data2 = new Data2();
		
		new Thread(() ->  {for (int i = 0; i < 10; i++) {
			data2.increment();
		}},"A").start();
		
		new Thread(() ->  {for (int i = 0; i < 10; i++) {
			data2.decrement();
		}},"B").start();
		
		new Thread(() ->  {for (int i = 0; i < 10; i++) {
			data2.increment();
		}},"C").start();
		
		new Thread(() ->  {for (int i = 0; i < 10; i++) {
			data2.increment();
		}},"D").start();
		
	}
}
class Data2 {
	private int number = 0;
	Lock lock = new ReentrantLock();
	Condition condition = lock.newCondition();
	
	public void increment() {
		lock.lock();	
		try {
			while (number != 0) {
				//等待
				condition.await();
			}
		    number++;
		    System.out.println(Thread.currentThread().getName()+"=>"+number);
		    //通知其他线程，+1完毕了
		    condition.signalAll();
		} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
		}
	}
	
	public void decrement() {
		lock.lock();	
		try {
			while (number == 0) {
				//等待
				condition.await();
			}
		    number--;
		    System.out.println(Thread.currentThread().getName()+"=>"+number);
		    //通知其他线程，+1完毕了
		    condition.signalAll();
		} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
		}
	}
}

结果：实现互斥操作

 相比于wait和notify方法只能随机唤醒线程，Condition的优势：精准的通知和唤醒的线程！

通过condition1、condition2 、condition3 的交替使用，完成流程控制A-->B-->C

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * A 执行完 调用B
 * B 执行完 调用C
 * C 执行完 调用A
 */

public class C {

    public static void main(String[] args) {
        Data3 data3 = new Data3();
        new Thread(()->{
            for(int i=0;i<10;i++){
                data3.printA();
            }
        },"A").start();
        new Thread(()->{
            for(int i=0;i<10;i++){
                data3.printB();
            }
        },"B").start();
        new Thread(()->{
            for(int i=0;i<10;i++){
                data3.printC();
            }
        },"C").start();
    }
}

class Data3{
    //资源类
    private Lock lock=new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();
    private int number = 1; //1A 2B 3C

    public void printA(){
        lock.lock();
        try {
            //业务 判断 -> 执行 -> 通知
            while(number!=1){
                //等待
                condition1.await();
            }
            //操作
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            //唤醒指定的线程
            number=2;
            condition2.signal(); // 唤醒2

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void printB(){
        lock.lock();
        try {
            //业务 判断 -> 执行 -> 通知
            while (number!=2){
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            //唤醒3
            number=3;
            condition3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void printC(){
        lock.lock();
        try {
            //业务 判断 -> 执行 -> 通知
            while(number!=3){
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            //唤醒1
            number=1;
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

结果：实现了三个流程的互斥控制

5、6锁现象

如何判断锁的是谁！锁到底锁的是谁？

锁会锁住：对象、Class

深刻理解我们的锁

问题1：sendMes和call之间停了4秒，下面这段代码运行是先发短信还是先打电话呢？

public class Test1 {
	public static void main(String[] args) {
		Phone phone = new Phone();
		
		new Thread(() -> {
			phone.sendMes();
		},"A").start();

		
		try {
			TimeUnit.SECONDS.sleep(4);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		new Thread(() -> {
			phone.call();
		},"B").start();
		
	}
}
class Phone {
	
	public synchronized void sendMes() {
		System.out.println("发短信");
	}
	public synchronized void call() {
		System.out.println("打电话");
	}
	
}

答案是：

---

问题2 ：还是一样，下面这段代码运行是先发短信还是先打电话呢？

public class Test1 {
	public static void main(String[] args) {
		Phone phone = new Phone();
		
		new Thread(() -> {
			try {
				TimeUnit.SECONDS.sleep(4);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			phone.sendMes();
		},"A").start();
		
//		try {
//			TimeUnit.SECONDS.sleep(4);
//		} catch (InterruptedException e) {
//			// TODO Auto-generated catch block
//			e.printStackTrace();
//		}
		
		new Thread(() -> {
			phone.call();
		},"B").start();
		
	}
}
class Phone {
	
	public synchronized void sendMes() {
		System.out.println("发短信");
	}
	public synchronized void call() {
		System.out.println("打电话");
	}
	
}

答案是：

为什么呢？

• 原因：并不是按代码先后顺序执行！是因为synchronized 锁的对象是方法的调用者！对于两个方法用的是同一个锁，问题一的代码，sendMes先拿到锁所以先执行，而问题二的代码因为在sendMes调用之前停了4秒，所以call先拿到锁，call先执行，sendMes阻塞等待call执行完。
• 一把锁，谁拿到锁谁先执行！另外一个则等待！

---

问题3：创建两个对象，一个调用发短信，一个调用打电话，那么整个顺序是怎么样的呢？

package 锁;

import java.util.concurrent.TimeUnit;

public class Test1 {
	public static void main(String[] args) throws InterruptedException {
		Phone phone1 = new Phone();
		Phone phone2 = new Phone();
		
		new Thread(() -> {
			
			try {
				phone1.sendMes();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			
		},"A").start();
		
		TimeUnit.SECONDS.sleep(2);
		
		new Thread(() -> {
			phone2.call();
		},"B").start();
		
		
	}
}
class Phone {
	
	public synchronized void call() {
		System.out.println("打电话");
	}
	
	public synchronized void sendMes() throws InterruptedException {
		TimeUnit.SECONDS.sleep(4);
		System.out.println("发短信");
	}
	
	public void hello () {
		System.out.println("hello world!!!");
	}
}

结果：

 我们可以看到代码中sendMes方法先获得锁，并且在方法中停了4秒，但是并没有造成call方法阻塞，这是因为是两个不同的对象，每个对象都有一把锁

---

问题4：​​​​​两个对象，如果我们把synchronized的方法加上static变成静态方法！那么顺序又是怎么样的呢？

package 锁;

import java.util.concurrent.TimeUnit;

public class Test1 {
	public static void main(String[] args) throws InterruptedException {
		Phone phone1 = new Phone();
		Phone phone2 = new Phone();
		
		new Thread(() -> {
			
			try {
				phone1.sendMes();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			
		},"A").start();
		
		TimeUnit.SECONDS.sleep(2);
		
		new Thread(() -> {
			phone2.call();
		},"B").start();
		
		
	}
}
class Phone {
	
	public synchronized static void call() {
		System.out.println("打电话");
	}
	
	public synchronized static void sendMes() throws InterruptedException {
		TimeUnit.SECONDS.sleep(4);
		System.out.println("发短信");
	}
}

结果：

对于static静态方法来说，对于整个类Class来说只有一份，如果静态static方法使用synchronized锁定，那么这个synchronized锁会锁住整个Class对象！不管多少个对象，对于静态的锁都只有一把锁，谁先拿到这个锁就先执行，其他的进程都需要等待！
 

---

 问题6：一个对象，如果我们使用一个静态同步方法、一个同步方法、一个对象调用顺序是什么？

package 锁;

import java.util.concurrent.TimeUnit;

public class Test1 {
	public static void main(String[] args) throws InterruptedException {
		Phone phone1 = new Phone();
		//Phone phone2 = new Phone();
		
		new Thread(() -> {
			
			try {
				phone1.sendMes();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			
		},"A").start();
		
		TimeUnit.SECONDS.sleep(2);
		
		new Thread(() -> {
			phone1.call();
		},"B").start();
	}
}
class Phone {
	
	public synchronized static void call() {
		System.out.println("打电话");
	}
	
	public synchronized  void sendMes() throws InterruptedException {
		TimeUnit.SECONDS.sleep(4);
		System.out.println("发短信");
	}
}

结果：

事实证明，打电话先执行了，因为static call方法使用的Class锁，sendMes使用的是对象锁，所以不会造成阻塞

---

小结：Class锁只有一把，所有静态资源共用，而对象锁是每个对象有一把

6、不安全的集合类

List不安全

我们来看一下List这个集合类：

//java.util.ConcurrentModificationException 并发修改异常！
public class ListTest {
    public static void main(String[] args) {

        List