全部测试代码

什么是JUC

JUC就是java.util.concurrent工具包的简称

 

线程和进程

进程

一个在内存中运行的应用程序。每个进程都有自己独立的一块内存空间，一个进程可以有多个线程，比如在Windows系统中，一个运行的xx.exe就是一个进程。

线程

进程中的一个执行任务（控制单元），负责当前进程中程序的执行。一个进程至少有一个线程，一个进程可以运行多个线程，多个线程可共享数据。

java默认有2个线程 mian线程 gc线程

并行和并发有什么区别？

• 并发：多个任务在同一个 CPU 核上，按细分的时间片轮流(交替)执行，从逻辑上来看那些任务是同时执行。

• 并行：单位时间内，多个处理器或多核处理器同时处理多个任务，是真正意义上的“同时进行”。

• 串行：有n个任务，由一个线程按顺序执行。由于任务、方法都在一个线程执行所以不存在线程不安全情况，也就不存在临界区的问题。

做一个形象的比喻：

并发 = 两个队列和一台咖啡机。

并行 = 两个队列和两台咖啡机。

串行 = 一个队列和一台咖啡机。

并发变成的本质: 充分利用CPU资源

线程的状态

NEW  //新生
RUNNABLE,// 运行
BLOCKED,//阻塞
WAITING,// 等待,死等 
TIMED_WAITING,// 超时等待
TERMINATED;// 终止

wait/sleep的区别 ?

1. 来自不同的类

   1. wait --> Object

   2. sleep --> Thread

2. 锁的释放

   1. wait 会释放锁

   2. sleep 抱着锁睡觉,不会释放锁

3. 使用的范围不同

   1. wait 必须在同步代码块

   2. sleep 可以在任何地方睡

4. 是否需要捕获异常

   1. wait 需要捕获异常wait需要被唤醒，

   2. sleep 须捕获异常 ,sleep不需要被唤醒

Lock锁

传统synchronized

 

 

公平锁: 十分公平 , 可以先来后到

非公平锁: 不公平 , 可以插队 (默认使用)

package com.juc;
 
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
 
//买票
public class SaleTickDemo2 {
    public static void main(String[] args) {
//        多线程操作
        Ticket2 ticket = new Ticket2();
 
//        Runnable ; @FunctionalInterface 函数式接口    lambda   (参数) - > {代码}
        new Thread( ()-> {
            for (int i = 0; i < 60 ; i++) {
                ticket.sale();
            }
        },"A").start();
        new Thread( ()-> {
            for (int i = 0; i < 60 ; i++) {
                ticket.sale();
            }
        },"B").start();
        new Thread( ()-> {
            for (int i = 0; i < 60 ; i++) {
                ticket.sale();
            }
        },"C").start();
    }
}
/*
*  1. new ReentrantLock()
*  2. lock.lock(); 加锁
*  3.finally  lock.unlock();解锁
* */
class Ticket2 {
    private int num = 50;
 
    Lock lock = new ReentrantLock();
 
//    买票的方法
    public void sale(){
        lock.lock(); //加锁
        try {
//            业务代码
            if (num > 0) {
                System.out.println(Thread.currentThread().getName() + "第几张" + (num--) + "剩余" + num + "张");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
//            解锁
            lock.unlock();
        }
    }
}

Synchronized 与 lock 区别

1. Synchronized 内置java关键字, lock是java的一个类

2. Synchronized 无法判断获取锁的状态, lock可以判断是否获取到了锁

3. Synchronized 会自动释放锁 , lock必须手动释放锁, 不释放锁会导致死锁

4. Synchronized 线程1 获得锁 线程2 等待 线程1阻塞线程2 会死等; lock 不一定会等待 lock.tryLock(); 尝试获取锁

5. Synchronized 可重入锁,不可中断,非公平. lock 可重入锁,可以判断锁 ,锁的公平(可以自定义)

6. Synchronized 适合少量代码同步问题, lock 适合大量代码同步

生产者消费者问题

package com.pc; 
/*
* 线程之间的通信问题,生产者和消费者问题   等待唤醒   通知唤醒
* 线程交替执行 A  B  操作同一变量*/
public class A {
    public static void main(String[] args) {
 
        Data date = new Data();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    date.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    date.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
    }
 
 
}
// 等待  业务  通知
class Data{
    private int number = 0;
 
    public synchronized void increment() throws InterruptedException {
//        +1
        if (number != 0) {
// 等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"  "+number);
//        通知其他线程  我 +1 完毕了
        this.notifyAll();
    }
    public synchronized void decrement() throws InterruptedException {
//        -1
        if (number == 0) {
//等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"  "+number);
//        通知其他线程 我-1  完毕了
        this.notifyAll();
    }
}

 如果有 ABCD四个线程, 会出现虚假唤醒的情况 此时, 将if判断改为while 判断

package com.pc;
/*
* 线程之间的通信问题,生产者和消费者问题   等待唤醒   通知唤醒
* 线程交替执行 A  B  操作同一变量*/
public class A {
    public static void main(String[] args) {
 
        Data date = new Data();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    date.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    date.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    date.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    date.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();
    }
 
}
 
// 等待  业务  通知
class Data{
    private int number = 0;
 
    public synchronized void increment() throws InterruptedException {
//        +1
        while (number != 0) {
// 等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"  "+number);
//        通知其他线程  我 +1 完毕了
        this.notifyAll();
    }
    public synchronized void decrement() throws InterruptedException {
//        -1
        while (number == 0) {
//等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"  "+number);
//        通知其他线程 我-1  完毕了
        this.notifyAll();
    }
}

JUC版的生产者消费者

通过Lock 找到 Condition

 

package com.pc;
 
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
 
public class B {
    public static void main(String[] args) {
 
        Data2 date = new Data2();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    date.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    date.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    date.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    date.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();
 
    }
}
 
// 等待  业务  通知
class Data2{
    private int number = 0;
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
//            condition.wait(); // 等待
//            condition.signalAll(); // 唤醒
 
    public  void increment() throws InterruptedException {
        lock.lock();
        try {
//            业务代码
//        +1
            while (number != 0) {
                condition.await(); // 等待
            }
            number++;
            System.out.println(Thread.currentThread().getName()+"-->"+number);
//        通知其他线程  我 +1 完毕了
            condition.signalAll(); // 唤醒
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public  void decrement() throws InterruptedException {
        lock.lock();
        try {
            //        -1
            while (number == 0) {
                condition.await();// 等待
            }
            number--;
            System.out.println(Thread.currentThread().getName()+"-->"+number);
//        通知其他线程 我-1  完毕了
            condition.signalAll(); // 唤醒
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

不会出现虚假唤醒,但是 唤醒的没有规律

condition 精准通知和唤醒线程

package com.pc;
 
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;
    public void printA(){
        lock.lock();
        try {
            while (number != 1) {
//                等待
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName() + "--->A");
//            唤醒指定的人
//            业务代码 判断是否等待  执行   通知
            number = number+1;
            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() + "--->B");
            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() + "--->C");
            number = 1;
            condition1.signal();
//            业务代码 判断是否等待  执行   通知
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

8锁现象

怎么判断锁的是谁

8锁 测试代码

new this 具体的都关系

static 锁的是Class

集合类不安全

List - CopyOnWriteArrayList

package com.unsafe;
 
import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;
 
/*
* java.util.ConcurrentModificationException 并发修改异常
* */
public class ListTest {
    public static void main(String[] args) {
//        List list = Arrays.asList("1", "12", "13");
//        list.forEach(System.out::println);
 
//        并发下 ArrayList 不安全
        /*
        * 解决方法：
        * 1. List list = new Vector<>();
        * 2. List list = Collections.synchronizedList(new ArrayList<>());
        * 3. List list = new CopyOnWriteArrayList<>();
        * */
//        CopyOnWrite写入是复制  多个线程调用的时候 读取的是固定的，写入避免覆盖，写入的时候先copyof一份 ，最后在set回去
//        CopyOnWriteArrayList 比 Vector 厉害在哪
        List list = new CopyOnWriteArrayList<>();
        for (int i = 1; i <= 10; i++) {
            new Thread(() -> {
                list.add(UUID.randomUUID().toString().substring(0, 5));
                System.out.println(list);
            }, String.valueOf(i)).start();
        }
    }
}

set - ConcurrentSkipListSet

package com.unsafe;
 
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.ConcurrentSkipListSet;
 
/*
*解决方案:
* 1.Set set = Collections.synchronizedSet(new HashSet<>());
* 2.Set set = new ConcurrentSkipListSet<>();
* */
public class SetTest {
    public static void main(String[] args) {
//        Set set = new ConcurrentSkipListSet<>();
        HashSet