JUC详解

1.什么是JUC

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

2.进程和线程

进程是一个程序，比如qq.exe，360.exe，进程包含线程，一个进程最少要有一个线程

线程是负责程序中的一个内容，比如qq，我可以有一个线程是接受消息，一个线程是发消息。

Java默认有两个线程，Main,GC。

Java能开线程吗？不能，调用的是本地方法，也就是c++开的，这个是JVM中的内容，不理解的可以去看我写的JVM，那里有详解。

3.Lock锁

• 传统的synchronized
• Lock接口

Synchronized 和 Lock 区别：

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

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

3 、 Synchronized 会自动释放锁， lock 必须要手动释放锁！如果不释放锁， 死锁

4 、 Synchronized 线程 1 （获得锁，阻塞）、线程 2 （等待，傻傻的等）； Lock 锁就不一定会等待下

去；

5 、 Synchronized 可重入锁，不可以中断的，非公平； Lock ，可重入锁，可以 判断锁，非公平（可以

自己设置）；

6 、 Synchronized 适合锁少量的代码同步问题， Lock 适合锁大量的同步代码！

 

4.生产者消费者问题

就是一个线程负责生产产品，另一个线程消费产品，这两个线程之间进行通信，因为只有生产的有商品才能消费，如果还没生产出来就要等待

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

能从上面这个代码发现什么问题吗？请思考三分钟再往下看。

 

存在虚假唤醒的问题。

什么是虚假唤醒？

因为用的是if语句，当线程判断是否符合if的条件并且成功后已经执行到if语句里面，这时候突然切换到另一个线程执行操作之后导致判断条件已经不符合了，但是这个时候你已经进去if里面了，这时候如果你的操作就是错的，但是还是会执行。

怎么解决？

if改为while，不断地判断，如果不符合条件就不能执行语句。

上面这个是以前我们学的多线程解决方法，下面来看JUC是如何解决的。

上面的调用线程的代码都一样，我就不写出来了，只需要改一下资源类，其实就是用Condition

class Data2{ // 数字 资源类
 private int number = 0; 
Lock lock = new ReentrantLock();
 Condition condition = lock.newCondition(); 
//condition.await(); 
// 等待 
//condition.signalAll(); 
// 唤醒全部 //+1 
public void increment() throws InterruptedException {
lock.lock(); 
try {
// 业务代码 
while (number!=0){ //0 
// 等待
 condition.await(); }
number++; 
System.out.println(Thread.currentThread().getName()+"=>"+number);
 // 通知其他线程，我+1完毕了 
condition.signalAll(); 
} 
catch (Exception e) { e.printStackTrace(); }
 finally { lock.unlock(); } }
public synchronized void decrement() throws InterruptedException { 
lock.lock(); 
try {while (number==0){ // 1
 // 等待 
condition.await(); }
number--; 
System.out.println(Thread.currentThread().getName()+"=>"+number); 
// 通知其他线程，我-1完毕了 
condition.signalAll(); } 
catch (Exception e) { e.printStackTrace(); } 
finally { lock.unlock(); } }

这个Condition的好处就是它可以指定顺序的调用，可以唤醒指定的线程

package sort;

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

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

class Data3 { // 资源类 Lock
   
    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() + "=>AAAAAAA"); // 唤醒，唤醒指定的人，B
            number = 2;
            condition2.signal();
        } 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() + "=>BBBBBBBBB"); // 唤醒，唤醒指定的人，c 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() + "=>BBBBBBBBB"); // 唤醒，唤醒指定的人，c
            number = 1;
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}