Java多线程 JUC并发编程（第一天）

最新推荐文章于 2021-09-24 14:48:23 发布

别訆我小内脏

最新推荐文章于 2021-09-24 14:48:23 发布

阅读量112

点赞数

分类专栏： JUC 多线程 JUC 并发编程

本文链接：https://blog.csdn.net/weixin_43092820/article/details/117000015

版权

JUC 多线程同时被 2 个专栏收录

3 篇文章 0 订阅

订阅专栏

JUC 并发编程

1 篇文章 0 订阅

订阅专栏

多线程进阶=>JUC并发编程

1、什么是JUC

面试高频问 源码 + 官方文档
在这里插入图片描述
Java.util.concurrent 工具包

回顾以前：
　　业务：普通的线程代码 Thread
　　Runnable 没有返回值、效率相比入 Callable 相对较低！
在这里插入图片描述

2、线程和进程

2.1、线程和进程

进程：就是一个程序。如：QQ.exe ; Music.exe
一个进程通常包含多个线程，至少包含一个！
在这里插入图片描述
1、Java 默认有几个线程？
答：两个一个main线程、一个GC线程

2、对于Java而言，有哪几种开通线程分方法？
答：Thread、Runnable、Callable

3、Java真的可以开启线程吗？
答：开不了。

// 调用本地方法，底层的C++ ，Java 无法直接操作硬件
private native void start0();

源码如下：

    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 */
            }
        }
    }

    private native void start0();

2.2、并发、并行

并发（多线程操作同一个资源）

CPU 一核，模拟出来多条线程。天下武功，唯快不破。时间切片，快速交替

并行（多个人一起行走）

CPU 多核，多个线程可以同时执行；比如 线程池

通过代码获取本机的 CPU 核数

public static void main(String[] args) {
        // 获取 CPU 的核数
        // CPU 密集型，IO密集型
        System.out.println(Runtime.getRuntime().availableProcessors());
        // 获取 本机系统类型   windows 10
        System.out.println(System.getProperty("os.name").toLowerCase());
    }

并发编程的本质：充分利用CPU的资源

2.3、线程有几种状态

直接看源码，共六种状态

    public enum State {
        // 	新生
        NEW,

		//	运行
        RUNNABLE,

        //	阻塞
        BLOCKED,

        //	等待，死等
        WAITING,

		//	超时等待
        TIMED_WAITING,

		//	终止
        TERMINATED;
    }

2.4、wait / sleep 的区别

1、来自不同的类
wait => Object
sleep => thread
在这里插入图片描述

2、关于锁的释放
wait 会释放锁
sleep 不会释放锁

3、使用的范围不同
wait 必须在同步代码块中
sleep 任何地方都可以

4、是否需要捕获异常
wait 不需要捕获异常
sleep 必须要捕获异常

5、是否需要被唤醒
wait 需要
sleep 不需要被唤醒

3、Lock锁（重点）

3.1、传统 Synchronized

在这里插入图片描述
直接上代码看，使用 synchronized

// 基本的卖票的例子
public class Test01 {
    public static void main(String[] args) {
        // 并发：多线程操作同一个资源类
        Ticker ticker = new Ticker();

        // @FunctionalInterface 函数式接口，jdk1.8 lambda表达式 (参数)->{ 代码 }
        new Thread(() -> {
            for (int i = 0; i < 40; i++) {
                ticker.sale();
            }
        }, "A").start();

        new Thread(() -> {
            for (int i = 0; i < 40; i++) {
                ticker.sale();
            }
        }, "B").start();

        new Thread(() -> {
            for (int i = 0; i < 40; i++) {
                ticker.sale();
            }
        }, "C").start();
    }


}

// 资源类  OOP 面线对象原则
class Ticker {
    // 属性
    private int number = 30;

    // 方法
    public synchronized void sale() {
        if (number > 0) {
            System.out.println(Thread.currentThread().getName() + "卖出了第" + (number--)
                    + "张票，" + "剩余:" + number + "张票");
        }
    }
}

3.2、Lock 锁

在这里插入图片描述

公平锁：十分公平：必须排队
非公平锁：十分不公平：可以插队（默认）

java 代码

// 基本的卖票的例子
public class Test02 {
    public static void main(String[] args) {
        // 并发：多线程操作同一个资源类
        Ticker2 ticker = new Ticker2();

        // @FunctionalInterface 函数式接口，jdk1.8 lambda表达式 (参数)->{ 代码 }
        new Thread(() -> {for (int i = 0; i < 40; i++) ticker.sale();}, "A").start();
        new Thread(() -> {for (int i = 0; i < 40; i++) ticker.sale();}, "B").start();
        new Thread(() -> {for (int i = 0; i < 40; i++) ticker.sale();}, "C").start();

    }


}

// Lock三部曲
// 1、 new ReentrantLock();
// 2、 lock.lock(); // 加锁
// 3、 finally=> lock.unlock(); // 解锁
class Ticker2 {
    // 属性
    private int number = 30;
    
    Lock lock = new ReentrantLock();
    // 方法
    public void sale() {
        lock.lock();// 加锁
        try {
        	// 业务代码
            if (number > 0) {
                System.out.println(Thread.currentThread().getName() + "卖出了第" + (number--)
                        + "张票，" + "剩余:" + number + "张票");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();// 解锁
        }
    }
}

3.3、Synchronized 和 Lock 的区别

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

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

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

4、 Synchronized 线程1（获取锁 | 阻塞）、线程2（等待 | 死等）
Lock 锁就不一定会等待下去比如：lock.tryLock()

5、 Synchronized 可重入锁，不可以中断，非公平
Lock 可重入锁，可以判断锁，非公平（可以自己设置参数为公平或不公平）

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

3.4、锁是什么？如何判断锁的是谁？

4、生产者和消费者问题

面试必问：单例模式、排序算法、生产者和消费者、死锁

4.1、生产者和消费者问题 Synchronized 版

直接上代码

public class A {
    /**
     * 线程之间的通信问题：生产者和消费者问题！ 等待唤醒，通知唤醒
     * 线程交替执行 A B 操作同一个变量 num = 0
     * A num+1
     * B num-1
     */
    public static void main(String[] args) {
        Data data = new Data();

        new Thread(()->{
            try {
                for (int i = 0; i < 10; i++) {
                    data.increment();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();

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

4.2、假如存在多条线程，会产生虚假唤醒

在这里插入图片描述
所以把 if 改为 while 判断

public class A {
    /**
     * 线程之间的通信问题：生产者和消费者问题！ 等待唤醒，通知唤醒
     * 线程交替执行 A B 操作同一个变量 num = 0
     * A num+1
     * B num-1
     */
    public static void main(String[] args) {
        Data data = new Data();

        new Thread(()->{
            try {
                for (int i = 0; i < 10; i++) {
                    data.increment();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();

        new Thread(()->{
            try {
                for (int i = 0; i < 10; i++) {
                    data.decrement();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"B").start();

        new Thread(()->{
            try {
                for (int i = 0; i < 10; i++) {
                    data.increment();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"C").start();

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

4.3、生产者和消费者问题 JUC 版

![在这里插入图片描述](https://img-blog.csdnimg.cn/20210519215844339.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzA5MjgyMA==,size_16,color_FFFFFF,t_70) **在 jdk 帮助文档里，通过 Lock 找到 Condition** ![在这里插入图片描述](https://img-blog.csdnimg.cn/20210519215944173.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzA5MjgyMA==,size_16,color_FFFFFF,t_70) 代码实现

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

public class B {
    /**
     * 线程之间的通信问题：生产者和消费者问题！ 等待唤醒，通知唤醒
     * 线程交替执行 A B 操作同一个变量 num = 0
     * A num+1
     * B num-1
     */
    public static void main(String[] args) {
        Data2 data = new Data2();
        new Thread(()->{for (int i = 0; i < 10; i++)data.increment();},"A").start();
        new Thread(()->{for (int i = 0; i < 10; i++)data.decrement();},"B").start();
        new Thread(()->{for (int i = 0; i < 10; i++)data.increment();},"C").start();
        new Thread(()->{for (int i = 0; i < 10; i++)data.decrement();},"D").start();
    }
}

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

    }
    // -1
    public void decrement(){
            lock.lock();
        try {
            while (number == 0) {
                //等待
                condition.await();
            }
            number --;
            // 通知其他线程，我-1完毕了
            condition.signalAll();
            System.out.println(Thread.currentThread().getName() + " => "+ number);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }
}

4.4、Condition 精准的通知和唤醒线程

![在这里插入图片描述](https://img-blog.csdnimg.cn/20210529203448790.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzA5MjgyMA==,size_16,color_FFFFFF,t_70) **代码测试：**

package com.feimai.test.JUCTest.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 conditionA = lock.newCondition();
    private Condition conditionB = lock.newCondition();
    private Condition conditionC = lock.newCondition();
    private int number = 1;

    public void printA(){
        lock.lock();
        try {
            // 业务，判断-> 执行-> 通知
            while (number != 1) {
                // 等待
                conditionA.await();
            }
            System.out.println(Thread.currentThread().getName()+"->  AAA");
            number = 2;
            // 唤醒 B 方法
            conditionB.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void printB(){
        lock.lock();
        try {
            while (number != 2) {
                // 等待
                conditionB.await();
            }
            System.out.println(Thread.currentThread().getName()+"->  BBB");
            number = 3;
            // 唤醒 C 方法
            conditionC.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void printC(){
        lock.lock();
        try {
            while (number != 3) {
                // 等待
                conditionC.await();
            }
            number = 1;
            System.out.println(Thread.currentThread().getName()+"->  CCC");
            // 唤醒 A 方法
            conditionA.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

控制台打印：精准通知
在这里插入图片描述

5、8锁现象

如何判断锁的是谁？深刻理解我们的锁

8 锁：就是关于锁的 8 个问题

1、两个普通同步方法，两个线程，标准打印发短信还是打电话？结果： 1.发短信 2.打电话
2、新增TimeUnit.SECONDS.sleep(1) 给发短信方法，两个线程，标准打印？结果： 1.发短信 2.打电话
3、新增普通方法 hello() ，和同步方法测试，两个线程，标准打印？结果： 1.hello 2.发短信
4、两个对象，两个同步方法，发短信 sleep，打电话正常，标准打印？结果： 1.打电话 2.发短信
5、新增两个静态同步方法，一个对象，标准打印？结果： 1.发短信 2.打电话
6、新增两个静态同步方法，两个对象，标准打印？结果： 1.发短信 2.打电话
7、一个静态的同步方法有sleep，一个普通的同步方法，一个对象，标准打印？结果： 1.打电话 2.发短信
8、一个静态的同步方法有sleep，一个普通的同步方法，两个对象，标准打印？结果： 1.打电话 2.发短信
总结：
1、非静态方法的锁默认为 this，也就是new的对象，
静态方法的锁，为对应的 Class 实例，也就是类模板
2、某一个时刻内，只能有一个线程持有锁，无论几个方法

代码实现

package com.feimai.test.JUCTest.lock8;
import java.util.concurrent.TimeUnit;
/**
 *  8 锁：就是关于锁的 8 个问题
 *  1、两个普通 同步 方法，两个线程，标准打印  发短信  还是  打电话？  结果： 1.发短信  2.打电话
 *  2、新增TimeUnit.SECONDS.sleep(1) 给发短信方法，两个线程，标准打印？   结果： 1.发短信  2.打电话
 *  3、新增普通方法 hello() ，和同步方法测试，两个线程，标准打印？    结果： 1.hello  2.发短信
 *  4、两个对象，两个同步方法，发短信 sleep，打电话 正常，标准打印？   结果： 1.打电话  2.发短信
 *  5、新增两个静态同步方法，一个对象，标准打印？   结果： 1.发短信  2.打电话
 *  6、新增两个静态同步方法，两个对象，标准打印？   结果： 1.发短信  2.打电话
 *  7、一个静态的同步方法 有sleep，一个普通的同步方法 ，一个对象，标准打印？   结果： 1.打电话  2.发短信
 *  8、一个静态的同步方法 有sleep，一个普通的同步方法 ，两个对象，标准打印？   结果： 1.打电话  2.发短信
 *
 *  总结：
 *  1、非静态方法的锁 默认为 this，也就是new的对象，
 *     静态方法的锁，为对应的 Class 实例，也就是 类模板
 *  2、某一个时刻内，只能有一个线程持有锁，无论几个方法
 */
public class Test1 {
    public static void main(String[] args) {
        // 两个对象的Class 类模板只有一个，static 锁的是 Class
        // 两个对象，两个调用者，两把锁
        Phone phone = new Phone();
        Phone phone2 = new Phone();
        // 锁的存在
        new Thread(()->{
            phone.sendSms();
        },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        new Thread(()->{
            phone2.call();
        },"B").start();
    }
}
// Phone 唯一的一个 Class 对象
class Phone{
    // synchronized 锁的对象是 方法的调用者
    // 两个方法用的是同一个锁，谁先拿到  谁执行
    // 加了 static ，类一加载就有了，锁的是 Class
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public static synchronized void call(){
        System.out.println("打电话");
    }
    // 这里没有锁！不是同步方法，不受锁的影响
    public void hello(){
        System.out.println("Hello");
    }
}

6、集合类不安全

6.1、List 类不安全

解决方案：

List<String> list = new Vector<>();
List<String> list = Collections.synchronizedList(new ArrayList<>());
List<String> list = new CopyOnWriteArrayList<>()；

代码实现

package com.feimai.test.JUCTest.UNsafe;

import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;

// java.util.ConcurrentModificationException 并发修改异常！
public class ListTest {
    public static void main(String[] args) {
        // 并发下 ArrayList 不安全的吗，Synchronized；
        /**
         * 解决方案；
         * 1、List<String> list = new Vector<>();
         * 2、List<String> list = Collections.synchronizedList(new ArrayList<>
         ());
         * 3、List<String> list = new CopyOnWriteArrayList<>()；
         */
        // CopyOnWrite 写入时复制 COW 计算机程序设计领域的一种优化策略；
        // 多个线程调用的时候，list，读取的时候，固定的，写入（覆盖）
        // 在写入的时候避免覆盖，造成数据问题！
        // 读写分离
        // CopyOnWriteArrayList 比 Vector Nb 在哪里？
        List<String> list = new CopyOnWriteArrayList();

        for (int i = 1; i < 10; i++) {
            new Thread(() -> {
                list.add(UUID.randomUUID().toString().substring(0, 5));
                System.out.println("list = " + list);
            }, String.valueOf(i)).start();
        }
    }
}

6.2、 Set 不安全

解决方案：

Set<String> set = Collections.synchronizedSet(new HashSet<>());
Set<String> set = new CopyOnWriteArraySet<>();

代码实现

package com.feimai.test.JUCTest.UNsafe;

import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArraySet;

// java.util.ConcurrentModificationException 并发修改异常！
public class SetTest {
    public static void main(String[] args) {
        /**
         * 解决方案；
         * 1、Set<String> set = Collections.synchronizedSet(new HashSet<>());
         * 2、Set<String> set = new CopyOnWriteArraySet<>();
         */
        Set<String> set = new CopyOnWriteArraySet<>();

        for (int i = 1; i < 20; i++) {
            new Thread(()->{
                set.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println("set = " + set);
            }).start();
        }
    }
}

hashSet 底层是什么？

HashSet 的 add 方法本质就是 HashMap 的 key ，因为Key 是无法重复的

源码分析

public HashSet() {
	map = new HashMap<>();
} 
// add set 本质就是 map key是无法重复的！
public boolean add(E e) {
	return map.put(e, PRESENT)==null;
} 
private static final Object PRESENT = new Object(); // 固定值

6.3、 Map 不安全

回顾Map基本操作
在这里插入图片描述
解决方案：

Map<String,String> map = Collections.synchronizedMap(new HashMap<>());
Map<String,String> map = new ConcurrentHashMap<>();

代码实现

package com.feimai.test.JUCTest.UNsafe;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;

// java.util.ConcurrentModificationException 并发修改异常！
public class MapTest {
    public static void main(String[] args) {
        /**
         * 解决方案；
         * 1、Map<String,String> map = Collections.synchronizedMap(new HashMap<>());
         * 2、Map<String,String> map = new ConcurrentHashMap<>();
         */
        //Map<String,String> map = new HashMap<>();
        // map 是这样用的吗？ 不是，工作中不用 HashMap
        // 默认等价于什么？ new HashMap<>(16,0.75);
        // 研究ConcurrentHashMap的原理
        Map<String,String> map = new ConcurrentHashMap<>();
        for (int i = 1; i < 20; i++) {
            new Thread(()->{
                map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0,5));
                System.out.println("map = " + map);
            },String.valueOf(i)).start();
        }
    }
}

7、Callable（简单）

在这里插入图片描述
根据官方文档可知：

callable 可以有返回值
callable 可以抛出异常
方法不同，Runnable是 run方法，Callable 是 call 方法

找到一个适配类 Class FutureTask 在这里插入图片描述
代码实现

package com.feimai.test.JUCTest.callable;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class CallableTest {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        // 适配类
        FutureTask<Integer> futureTask = new FutureTask<Integer>(myThread);
        new Thread(futureTask,"A").start();
        // 结果会被缓存，效率高
        new Thread(futureTask,"B").start();
        try {
            //这个get 方法可能会产生阻塞！把他放到最后
            Integer integer = futureTask.get();
            // 或者使用异步通信来处理！
            System.out.println("integer = " + integer);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

class MyThread implements Callable<Integer> {
    @Override
    public Integer call() {
        System.out.println("call");
        return 1024;
    }
}

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

8.1、CountDownLatch (减法计数器)

在这里插入图片描述

代码实现

package com.feimai.test.JUCTest.utils;

import java.util.concurrent.CountDownLatch;

public class CountDownLatchTest {

    public static void main(String[] args) {
        CountDownLatch countDownLatch = new CountDownLatch(5);
        for (int i = 1; i < 6; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+" Go out");
                countDownLatch.countDown();
            }).start();
        }
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("关门了。。。");
    }
}

8.2、CyclicBarrier(加法计数器)

在这里插入图片描述
代码实现

package com.feimai.test.JUCTest.utils;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierTest {

    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->{
            System.out.println("集齐七颗龙珠，召唤神龙！");
        });

        for (int i = 1; i <= 7; i++) {
            final int temp = i;
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"：收集了 "+ temp +" 棵龙珠");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

8.3、Semaphore 信号量

在这里插入图片描述

代码实现

package com.feimai.test.JUCTest.utils;

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

public class SemaphoreTest {

    public static void main(String[] args) {
        // 作用： 多个共享资源互斥的使用！并发限流，控制最大的线程数！
        Semaphore semaphore = new Semaphore(3);
        for (int i = 1; i <= 6; i++) {
            new Thread(()->{
                try {
                    // acquire() 获得
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName()+"：抢到车位");
                    TimeUnit.SECONDS.sleep(3);
                    System.out.println(Thread.currentThread().getName()+"：离开车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    // release()  释放
                    semaphore.release();
                }
            }).start();
        }

    }
}

别訆我小内脏

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java多线程 JUC并发编程（第一天）

多线程进阶=>JUC并发编程1、什么是JUC面试高频问源码 + 官方文档Java.util.concurrent 工具包回顾以前：　　业务：普通的线程代码 Thread　　Runnable 没有返回值、效率相比入 Callable 相对较低！2、线程和进程 2.1、线程和进程进程：就是一个程序。如：QQ.exe ; Music.exe一个进程通常包含多个线程，至少包含一个！1、Java 默认有几个线程？答：两个一个main线程、一个GC线程2、对
复制链接

扫一扫