juc线程间通信

最新推荐文章于 2024-07-30 20:50:32 发布
最新推荐文章于 2024-07-30 20:50:32 发布
阅读量156 收藏
点赞数
文章标签： java 数据结构与算法
原文链接：https://my.oschina.net/architectliuyuanyuan/blog/3083223
版权

两个线程，一个线程打印1-52，另一个打印字母A-Z打印顺序为12A34B...5152Z,
要求用线程间通信

1.synchronized实现

package com.liuyuanyuan.thread;
 
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
 
import org.omg.IOP.Codec;
 
 
class ShareDataOne//资源类
{
  private int number = 0;//初始值为零的一个变量
 
  public synchronized void increment() throws InterruptedException 
  {
     //1判断
     if(number !=0 ) {
       this.wait();
     }
     //2干活
     ++number;
     System.out.println(Thread.currentThread().getName()+"\t"+number);
     //3通知
     this.notifyAll();
  }
  
  public synchronized void decrement() throws InterruptedException 
  {
     // 1判断
     if (number == 0) {
       this.wait();
     }
     // 2干活
     --number;
     System.out.println(Thread.currentThread().getName() + "\t" + number);
     // 3通知
     this.notifyAll();
  }
}
 
/**
 * 
 * @Description:
 *现在两个线程，
 * 可以操作初始值为零的一个变量，
 * 实现一个线程对该变量加1，一个线程对该变量减1，
 * 交替，来10轮。 
 * @author liuyuan
 *
 *  * 笔记：Java里面如何进行工程级别的多线程编写
 * 1 多线程变成模板（套路）-----上
 *     1.1  线程    操作    资源类  
 *     1.2  高内聚  低耦合
 * 2 多线程变成模板（套路）-----下
 *     2.1  判断
 *     2.2  干活
 *     2.3  通知
 
 */
public class NotifyWaitDemoOne
{
  public static void main(String[] args)
  {
     ShareDataOne sd = new ShareDataOne();
     new Thread(() -> {
       for (int i = 1; i < 10; i++) {
          try {
            sd.increment();
          } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
          }
       }
     }, "A").start();
     new Thread(() -> {
       for (int i = 1; i < 10; i++) {
          try {
            sd.decrement();
          } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
          }
       }
     }, "B").start();
  }
}
/*
 * * 
 * 2 多线程变成模板（套路）-----下
 *     2.1  判断
 *     2.2  干活
 *     2.3  通知
 * 3 防止虚假唤醒用while
 * 
 * 
 * */

换成4个线程会导致错误，虚假唤醒
 
原因：在java多线程判断时，不能用if，程序出事出在了判断上面，
突然有一添加的线程进到if了，突然中断了交出控制权，
没有进行验证，而是直接走下去了，加了两次，甚至多次
如上飞机，突然说了飞机上有炸弹，下飞机，安置住宿，当再次登机的时候还是需要进行安检的。

如何解决呢 ？

解决虚假唤醒：查看API，java.lang.Object

 c72642c0c8b1a04216a926d8715cc128891.jpg
中断和虚假唤醒是可能产生的，所以要用loop循环，if只判断一次，while是只要唤醒就要拉回来再判断一次。if换成while

以上是用的synchronized来实现的

下面我们用jdk1.8的更好的实现方式

思路很简单

fb9b0916060933c525576f3d06416147f9f.jpg

接下来是具体的代码实现

Condition：查看API，java.util.concurrent

 
class BoundedBuffer {
   final Lock lock = new ReentrantLock();
   final Condition notFull  = lock.newCondition(); 
   final Condition notEmpty = lock.newCondition(); 
 
   final Object[] items = new Object[100];
   int putptr, takeptr, count;
 
   public void put(Object x) throws InterruptedException {
     lock.lock();
     try {
       while (count == items.length)
         notFull.await();
       items[putptr] = x;
       if (++putptr == items.length) putptr = 0;
       ++count;
       notEmpty.signal();
     } finally {
       lock.unlock();
     }
   }

2、线程间定制化调用通信

1、有顺序通知，需要有标识位
 
2、有一个锁Lock，3把钥匙Condition
 
3、判断标志位
 
4、输出线程名+第几次+第几轮
 
5、修改标志位，通知下一个
 
 以上可能比较晦涩，接下来看具体的代码实现

package com.liuyuanyuan.thread;
 
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
 
 
class ShareResource
{
  private int number = 1;//1:A 2:B 3:C 
  private Lock lock = new ReentrantLock();
  private Condition c1 = lock.newCondition();
  private Condition c2 = lock.newCondition();
  private Condition c3 = lock.newCondition();
 
  public void print5(int totalLoopNumber)
  {
     lock.lock();
     try 
     {
       //1 判断
       while(number != 1)
       {
          //A 就要停止
          c1.await();
       }
       //2 干活
       for (int i = 1; i <=5; i++) 
       {
          System.out.println(Thread.currentThread().getName()+"\t"+i+"\t totalLoopNumber: "+totalLoopNumber);
       }
       //3 通知
       number = 2;
       c2.signal();
     } catch (Exception e) {
       e.printStackTrace();
     } finally {
       lock.unlock();
     }
  }
  public void print10(int totalLoopNumber)
  {
     lock.lock();
     try 
     {
       //1 判断
       while(number != 2)
       {
          //A 就要停止
          c2.await();
       }
       //2 干活
       for (int i = 1; i <=10; i++) 
       {
          System.out.println(Thread.currentThread().getName()+"\t"+i+"\t totalLoopNumber: "+totalLoopNumber);
       }
       //3 通知
       number = 3;
       c3.signal();
     } catch (Exception e) {
       e.printStackTrace();
     } finally {
       lock.unlock();
     }
  }  
  
  public void print15(int totalLoopNumber)
  {
     lock.lock();
     try 
     {
       //1 判断
       while(number != 3)
       {
          //A 就要停止
          c3.await();
       }
       //2 干活
       for (int i = 1; i <=15; i++) 
       {
          System.out.println(Thread.currentThread().getName()+"\t"+i+"\t totalLoopNumber: "+totalLoopNumber);
       }
       //3 通知
       number = 1;
       c1.signal();
     } catch (Exception e) {
       e.printStackTrace();
     } finally {
       lock.unlock();
     }
  }  
}
 
 
/**
 * 
 * @Description: 
 * 多线程之间按顺序调用，实现A->B->C
 * 三个线程启动，要求如下：
 * 
 * AA打印5次，BB打印10次，CC打印15次
 * 接着
 * AA打印5次，BB打印10次，CC打印15次
 * ......来10轮  
 * @author liuyuan
 *
 */
public class ThreadOrderAccess
{
  public static void main(String[] args)
  {
     ShareResource sr = new ShareResource();
     
     new Thread(() -> {
       for (int i = 1; i <=10; i++) 
       {
          sr.print5(i);
       }
     }, "AA").start();
     new Thread(() -> {
       for (int i = 1; i <=10; i++) 
       {
          sr.print10(i);
       }
     }, "BB").start();
     new Thread(() -> {
       for (int i = 1; i <=10; i++) 
       {
          sr.print15(i);
       }
     }, "CC").start();   
     
     
  }
}

3.NotSafeDemo

需求：请举例说明集合类是不安全的

java.util.ConcurrentModificationException


ArrayList在迭代的时候如果同时对其进行修改就会
抛出java.util.ConcurrentModificationException异常
并发修改异常

List<String> list = new ArrayList<>();
for (int i = 0; i <30 ; i++) {
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,8));
                System.out.println(list);
            },String.valueOf(i)).start();
        }
 
看ArrayList的源码
public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}
没有synchronized线程不安全

如何解决呢 ？

ba36f3be80f39a76706592217b9b2a3ecd0.jpg

List<String> list = new Vector<>();

看Vector的源码
public synchronized boolean add(E e) {
    modCount++;
    ensureCapacityHelper(elementCount + 1);
    elementData[elementCount++] = e;
    return true;
}
有synchronized线程安全

List<String> list = Collections.synchronizedList(new ArrayList<>());
Collections提供了方法synchronizedList保证list是同步线程安全的
 
那HashMap，HashSet是线程安全的吗？也不是
所以有同样的线程安全方法

 81a69039b18dab6b5be2a96dc44289c2d48.jpg

终极大boss出来了：写时复制

1dc26ae357299bcb5daeaed593e301c6d3d.jpg

List<String> list = new CopyOnWriteArrayList<>();

接下来介绍一下写时复制

写时复制为了解决：不加锁性能提升出错误，加锁数据一致性能下降问题

接下来介绍CopyOnWriteArrayList

A thread-safe variant of ArrayList in which all mutative operations (add, set, and so on) are implemented by making a fresh copy of the underlying array.
CopyOnWriteArrayList是arraylist的一种线程安全变体，
其中所有可变操作（add、set等）都是通过生成底层数组的新副本来实现的。
 5ce690db6942f07f827379a19ef4f002da2.jpg

复制了一份，往里追加写

 
/**
 * Appends the specified element to the end of this list.
 *
 * @param e element to be appended to this list
 * @return {@code true} (as specified by {@link Collection#add})
 */
public boolean add(E e) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        Object[] elements = getArray();
        int len = elements.length;
        Object[] newElements = Arrays.copyOf(elements, len + 1);
        newElements[len] = e;
        setArray(newElements);
        return true;
    } finally {
        lock.unlock();
    }
}
 
 
 
CopyOnWrite容器即写时复制的容器。往一个容器添加元素的时候，不直接往当前容器Object[]添加，
而是先将当前容器Object[]进行Copy，复制出一个新的容器Object[] newElements，然后向新的容器Object[] newElements里添加元素。
添加元素后，再将原容器的引用指向新的容器setArray(newElements)。
这样做的好处是可以对CopyOnWrite容器进行并发的读，而不需要加锁，因为当前容器不会添加任何元素。
所以CopyOnWrite容器也是一种读写分离的思想，读和写不同的容器。

对于set和map有写时复制技术么？

当然是有的

Set<String> set = new HashSet<>();//线程不安全
 

Set<String> set = new CopyOnWriteArraySet<>();//线程安全
 
 
 
HashSet底层数据结构是什么？
HashMap  ?
 
但HashSet的add是放一个值，而HashMap是放K、V键值对
 
 
 
 
 
 
public HashSet() {
    map = new HashMap<>();
}
 
private static final Object PRESENT = new Object();
 
public boolean add(E e) {
    return map.put(e, PRESENT)==null;
}
 
 

Map<String,String> map = new HashMap<>();//线程不安全
 

Map<String,String> map = new ConcurrentHashMap<>();//线程安全
 
 
  
 

package com.liuyuanyuan.gmall.jucdemo;

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

/**
 * 请举例说明集合类是不安全的
 */
public class NotSafeDemo {
    public static void main(String[] args) {

        Map<String,String> map = new ConcurrentHashMap<>();
        for (int i = 0; i <30 ; i++) {
            new Thread(()->{
                map.put(Thread.currentThread().getName(),UUID.randomUUID().toString().substring(0,8));
                System.out.println(map);
            },String.valueOf(i)).start();
        }


    }

    private static void setNoSafe() {
        Set<String> set = new CopyOnWriteArraySet<>();
        for (int i = 0; i <30 ; i++) {
            new Thread(()->{
                set.add(UUID.randomUUID().toString().substring(0,8));
                System.out.println(set);
            },String.valueOf(i)).start();
        }
    }

    private static void listNoSafe() {
        //        List<String> list = Arrays.asList("a","b","c");
        //        list.forEach(System.out::println);
        //写时复制
        List<String> list = new CopyOnWriteArrayList<>();
        // new CopyOnWriteArrayList<>();
        //Collections.synchronizedList(new ArrayList<>());
        //new Vector<>();//new ArrayList<>();

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


}





    /**
     * 写时复制
     CopyOnWrite容器即写时复制的容器。往一个容器添加元素的时候，不直接往当前容器Object[]添加，
     而是先将当前容器Object[]进行Copy，复制出一个新的容器Object[] newElements，然后向新的容器Object[] newElements里添加元素。
     添加元素后，再将原容器的引用指向新的容器setArray(newElements)。
     这样做的好处是可以对CopyOnWrite容器进行并发的读，而不需要加锁，因为当前容器不会添加任何元素。
     所以CopyOnWrite容器也是一种读写分离的思想，读和写不同的容器。

     *
     *
     *
     *

    public boolean add(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            newElements[len] = e;
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }
     */


  

转载于:https://my.oschina.net/architectliuyuanyuan/blog/3083223

chongmen1956
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JUC多线程学习个人笔记
07-08
线程是进程内的执行单元，线程间的通信和资源共享更为便捷，但共享数据可能导致并发问题。 9. **管程（Monitor）**：Monitor是Java中的一种同步机制，确保同一时间只有一个线程可以访问特定的代码块或数据。Monitor...
heima-JUC-资料
04-25
8. **线程通信**：`Semaphore`（信号量）、`CountDownLatch`（倒计时器）、`CyclicBarrier`（循环栅栏）和`Phaser`（屏障）等工具类，用于控制线程间的同步和通信，实现特定的并发模式。 9. **Fork/Join框架**：...
JUC如是实现线程之间的通信
weixin_42022924的博客
10-29 337
1. Condition 组件 在jdk中，synchronized可以实现线程通信，wait/notify 方法；在Condition中提供了多线程协调的通信，可以让某一个线程等待，只有条件满足才能被唤醒； 1.1 Condition使用 ...
JUC 控制线程通信
weixin_44130043的博客
03-29 151
控制线程通讯  Condition 接口描述了可能会与锁有关联的条件变量。这些变量在用法上与使用 Object.wait 访问的隐式监视器类似，但提供了更强大的功能。需要特别指出的是，单个 Lock 可能与多个 Condition 对象关联。为了避免兼容性问题，Condition 方法的名称与对应的 Object 版本中的不同。  在 Condition 对象中，与 wait、notify 和...
JUC学习笔记（2）—线程间通信
java_kider的博客
07-31 186
import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; class ShareData { private int number = 0; private Lock lock = ...
JUC 线程间通信
深夜无眠的博客
04-19 770
本篇文章我将解释《并发编程的艺术》一书中一个经典的实现线程间通信的案例，主要是使用wait() 和 notifyAll() 方法来实现的。
JUC之线程间的通信
wdjnb的博客
12-30 396
线程通信 创建资源类，在资源类中创建属性和操作方法 在资源类里面操作 判断 干活 通知 创建多个线程，调用资源类的操作方法 线程通信的实现例子： 两个线程，实现对一个初始变量为0进行操作，一个线程对其+1，一个线程对其-1，使得变量结果不改变 使用Synchronized实现的线程通信： package com.JUC; /** * 创建资源类 */ class Share{ //初始值 private int number = 0; //创.
JUC- 线程间通信
che_j的博客
10-20 140
两个线程，一个线程对当前数值加 1，另一个线程对当前数值减 1
JUC | JUC线程间的通信
蕤荥的成长博客
11-09 234
多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同。 比如：线程A用来生成包子的，线程B用来吃包子的，包子可以理解为同一资源，线程A与线程B处理的动作，一个是生产，一个是消费，那么线程A与线程B之间就存在线程通信问题。
Java——JUC高并发编程，面试必问（ 线程间通信 ）
xiangqian0721的博客
10-20 112
3.线程间通信 线程间通信的模型有两种：共享内存和消息传递，以下方式都是基本这两种模型来实现的。我们来基本一道面试常见的题目来分析： 面试题 场景—两个线程，一个线程对当前数值加 1，另一个线程对当前数值减 1,要求用线程间通信。 3.1 synchronized 方案 /** * volatile 关键字实现线程交替加减 */ public class TestVolatile { /** * 交替加减 */ public static void main(String[] args){
JUC-线程间通信
Logan的博客
08-23 116
3 线程间通信 线程间通信的模型有两种：共享内存和消息传递，以下方式都是基于这两种模 型来实现的。 场景—两个线程，一个线程对当前数值加 1，另一个线程对当前数值减 1,要求 用线程间通信 3.1 synchronized 方案 /** * volatile 关键字实现线程交替加减 */ public class TestVolatile { /** * 交替加减 * * @param args */ public static void ma
JUC+课程源码+线程操作
09-04
它是并发编程中的重要工具，常用于线程间的通信和数据共享，如`ArrayBlockingQueue`、`LinkedBlockingQueue`和`PriorityBlockingQueue`等。 在`juc_atguigu`这个压缩包中，包含了上述组件的示例代码，通过实际运行...
JUC底层讲解，面试可用。
10-09
* 通信：进程间通信IPC，线程间可以直接读写进程数据段（如全局变量）来进行通信。 * 调度和切换：线程上下文切换比进程上下文切换要快得多。 并发和并行： * 并发：当有多个线程在操作时，如果系统只有一个CPU，...
个人学习-JUC-笔记
02-25
7. **线程间通信** - **wait()与notify()**：Object类的方法，用于线程间的协作。 - **Condition**：Lock接口的扩展，提供更灵活的唤醒等待机制。 - **CountDownLatch/CyclicBarrier/Semaphore**：信号量类，用于...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 452
1.导入hutool的maven依赖。2.复制一下代码执行。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 256
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 624
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
花几千上万学习Java，真没必要！（三十五）
最新发布
wehpd的博客
07-30 296
集合之Map
Java并发编程：JUC线程详解与实践
线程间的通信和同步是Java并发编程的重要部分，Java提供了一系列工具，如`synchronized`关键字、`wait()`, `notify()`, `notifyAll()`方法、`Lock`接口及其实现类（如`ReentrantLock`）、`Semaphore`信号量、`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值