尚桂谷 JUC synchronized lock 多线程编程集合的线程安全多线程锁 Callable FutureTask 辅助类读写锁阻塞队列 ThreadPool Fork/Join

AdamCafe

已于 2022-02-20 12:50:02 修改

阅读量3.2k

点赞数

分类专栏：并发编程文章标签：安全 css3 前端

于 2022-02-19 18:29:46 首次发布

本文链接：https://blog.csdn.net/AdamCafe/article/details/123018256

版权

并发编程专栏收录该内容

7 篇文章 0 订阅

订阅专栏

在这里插入图片描述

1.JUC概述

在这里插入图片描述

2.Lock接口

在这里插入图片描述

使用lock锁实现；
在这里插入图片描述

在这里插入图片描述

3.多线程编程（Synchronized和Lock）

在这里插入图片描述

在这里插入图片描述
使用synchronized实现多线程编程：

package sync;
//第一步 创建资源类，定义属性和操作方法
public class Share {
    //初始值
    private int number=0;
    //+1的方法
    public synchronized void incr() throws InterruptedException {
        //第二部 判断 干活 通知
        while (number != 0) { //判断number值是否是0，如果不是0，原地等待
            this.wait();
        }
        //如果是number值是0，就+1操作
        number++;
        System.out.println(Thread.currentThread().getName() + "::" + number);
        //通知其他线程
        this.notifyAll();
    }
    //-1的方法
    public synchronized void decr() throws InterruptedException {
        while (number != 1) {
            this.wait();
        }
        //干活
        number--;
        System.out.println(Thread.currentThread().getName() + "::" + number);
        this.notifyAll();
    }

    public static void main(String[] args) {
        //第三部：创建多个线程，调用资源类的操作方法
        lock.Share share = new lock.Share();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    share.incr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "AA").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    share.decr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "BB").start();


    }
}

使用lock实现多线程编程：

package lock;

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

public class Share {
    private int number=0;
    //创建lock
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    //+1的方法
    public void incr() throws InterruptedException {
        //上锁
        lock.lock();
        while (number != 0) {
            condition.await();
        }
        //干活
        number++;
        System.out.println(Thread.currentThread().getName() + "::" + number);
        //通知
        condition.signalAll();
        try {

        }finally {
            //解锁
            lock.unlock();
        }
    }
    //-1的方法
    public void decr() throws InterruptedException {
        //上锁
        lock.lock();
        while (number != 1) {
            condition.await();
        }
        //干活
        number--;
        System.out.println(Thread.currentThread().getName() + "::" + number);
        //通知
        condition.signalAll();
        try {

        }finally {
            //解锁
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        Share share = new Share();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    share.incr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "AA").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    share.decr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "BB").start();new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    share.incr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "CC").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    share.decr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "DD").start();

    }
}

线程间定制化通信：
在这里插入图片描述

package lock;

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

//第一步 创建资源来
class ShareResource{
    //定义标志位
    private int flag = 1;

    //创建lock锁
    private Lock lock = new ReentrantLock();

    //创建三个condition
    private Condition c1 = lock.newCondition();
    private Condition c2 = lock.newCondition();
    private Condition c3 = lock.newCondition();
    //打印5次，参数第几轮
    public  void  print5(int loop) throws InterruptedException {
        //上锁
        lock.lock();
        try {
            //判断
            while (flag != 1) {
                //等待
                c1.await();
            }
            //干活
            for (int i = 0; i <= 5; i++) {
                System.out.println(Thread.currentThread().getName() + "::" + i + ":轮数:" + loop);
            }
            //通知
            flag = 2;//修改标志位2
            c2.signal();
        }finally {
            //解锁
            lock.unlock();
        }
    }
    //打印10次，参数第几轮
    public  void  print10(int loop) throws InterruptedException {
        //上锁
        lock.lock();
        try {
            //判断
            while (flag != 2) {
                //等待
                c2.await();
            }
            //干活
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + "::" + i + ":轮数:" + loop);
            }
            //通知
            flag = 3;//修改标志位3
            c3.signal();
        }finally {
            //解锁
            lock.unlock();
        }
    }
    //打印15次，参数第几轮
    public  void  print15(int loop) throws InterruptedException {
        //上锁
        lock.lock();
        try {
            //判断
            while (flag != 3) {
                //等待
                c3.await();
            }
            //干活
            for (int i = 0; i < 15; i++) {
                System.out.println(Thread.currentThread().getName() + "::" + i + ":轮数:" + loop);
            }
            //通知
            flag = 1;//修改标志位1
            c1.signal();
        }finally {
            //解锁
            lock.unlock();
        }
    }


}

public class ThreadDemo3 {
    public static void main(String[] args) {
        ShareResource shareResource = new ShareResource();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    shareResource.print5(5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        },"AA").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    shareResource.print10(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        },"BB").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    shareResource.print15(15);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        },"CC").start();
    }
}

4.集合的线程安全

在这里插入图片描述

ArrayList 线程不安全
在这里插入图片描述
解决方案：

源码分析：

hashset 无序，不能重复，线程不安全：

hashMap线程不安全

5.多线程锁

在这里插入图片描述

在这里插入图片描述

什么是死锁

在这里插入图片描述

代码演示死锁：
在这里插入图片描述

6.Callable

在这里插入图片描述

7.JUC强大的辅助类

在这里插入图片描述

8.ReentrantReadWriteLock 读写锁

在这里插入图片描述

悲观锁效率低，不支持并发操作
在这里插入图片描述
乐观锁：通过版本号控制

行锁：可能会发生死锁

在这里插入图片描述

package readwrite;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

class MyCache {
    //创建map集合
    private volatile Map<String, Object> map = new HashMap<>();
    //创建读写锁
    private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    //放数据
    public void put(String key, Object value) {
        //添加写锁
        readWriteLock.writeLock().lock();
        //暂停一会
        try {
            System.out.println(Thread.currentThread().getName() + "正在写操作" + key);
            TimeUnit.MICROSECONDS.sleep(300);
            //放数据
            map.put(key,value);
            System.out.println(Thread.currentThread().getName() + "写完了" + key);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            //释放写锁
            readWriteLock.writeLock().unlock();
        }
    }

    //取数据
    public void get(String key) {
        //添加读锁
        readWriteLock.readLock().lock();
        //暂停一会
        try {
            Object result = null;
            System.out.println(Thread.currentThread().getName() + "正在读取操作" + key);
            TimeUnit.MICROSECONDS.sleep(300);
            result = map.get(key);
            System.out.println(Thread.currentThread().getName() + "取完了" + key);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            //释放读锁
            readWriteLock.readLock().unlock();

        }

    }


}

public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCache myCache = new MyCache();
        //创建线程放数据
        for (int i = 0; i < 5; i++) {
            final int num = i;
            new Thread(()->{
                myCache.put(num + "", num + "");
            },String.valueOf(i)).start();
        }
        //创建线程取数据
        for (int i = 0; i < 5; i++) {
            final int num = i;
            new Thread(()->{
                myCache.get(num + "");
            },String.valueOf(i)).start();
        }
    }

}

在这里插入图片描述

在这里插入图片描述
1

9.阻塞队列

在这里插入图片描述

在这里插入图片描述
阻塞队列的架构：

在这里插入图片描述

10.ThreadPool

在这里插入图片描述

底层的工作流程：

在这里插入图片描述
自定义线程池：

在这里插入图片描述

11. Fork/Join

在这里插入图片描述

代码演示：

在这里插入图片描述

12.CompletableFuture 异步回调

在这里插入图片描述

AdamCafe

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
尚桂谷 JUC synchronized lock 多线程编程集合的线程安全多线程锁 Callable FutureTask 辅助类读写锁阻塞队列 ThreadPool Fork/Join

1.JUC概述2.Lock接口使用lock锁实现；3.多线程编程（Synchronized和Lock）使用synchronized实现多线程编程：package sync;//第一步创建资源类，定义属性和操作方法public class Share { //初始值 private int number=0; //+1的方法 public synchronized void incr() throws InterruptedExce..
复制链接

扫一扫