多线程之间通信

于 2019-03-07 14:42:00 发布
阅读量146 收藏
点赞数
分类专栏： java 多线程 文章标签： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wz122330/article/details/88305645
版权

多线程之间通信

概述

马老师多线程视频学习总结（好记性不如烂笔头）。

多线程之间通信

使用volatile实现通信

模拟情形： 设计一个容器，两个线程。线程一给容器里面add元素，当容器中的元素个数为5个时，线程二结束。
未使用volatile关键字：

package com.wz.code.test.thread;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

public class Container1 {

    List lists = new ArrayList<>();

    public boolean add(Object o) {
        return lists.add(o);
    }

    public int size() {
        return lists.size();
    }

    public static void main(String[] args) {
        Container1 c1 = new Container1();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                c1.add(new Object());
                System.out.println("add " + i);

                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }, "t1").start();

        new Thread(() -> {
            while (true) {
                if (c1.size() == 5)
                    break;
            }
            System.out.println("t2 done, size is " + c1.size());
        }, "t2").start();
    }
}

程序执行结果：
在这里插入图片描述
使用volatile关键字：

package com.wz.code.test.thread;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

public class Container2 {

    volatile List lists = new ArrayList<>();

    public boolean add(Object o) {
        return lists.add(o);
    }

    public int size() {
        return lists.size();
    }

    public static void main(String[] args) {
        Container2 c1 = new Container2();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                c1.add(new Object());
                System.out.println("add " + i);

                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }, "t1").start();

        new Thread(() -> {
            while (true) {
                if (c1.size() == 5) {
                    break;
                }
            }
            System.out.println("t2 done, size is " + c1.size());
        }, "t2").start();
    }
}

在这里插入图片描述
使用synchronized 关键字：

package com.wz.code.test.thread;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

public class Container3 {

    volatile List lists = new ArrayList<>();

    public synchronized boolean add(Object o) {
        return lists.add(o);
    }

    public synchronized int size() {
        return lists.size();
    }

    public static void main(String[] args) {
        Container3 c1 = new Container3();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                c1.add(new Object());
                System.out.println("add " + i);

                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }, "t1").start();

        new Thread(() -> {
            while (true) {
                if (c1.size() == 5) {
                    break;
                }
            }
            System.out.println("t2 done, size is " + c1.size());
        }, "t2").start();
    }
}

在这里插入图片描述

使用synchronized，wait，notify/notifyAll

  • wait()使当前线程阻塞，前提是 必须先获得锁，一般配合synchronized 关键字使用，即，一般在synchronized 同步代码块里使用 wait()、notify/notifyAll() 方法。
  • 由于 wait()、notify/notifyAll() 在synchronized 代码块执行，说明当前线程一定是获取了锁的。
  • 当线程执行wait()方法时候，会释放当前的锁，然后让出CPU，进入等待状态。
    只有当 notify/notifyAll() 被执行时候，才会唤醒一个或多个正处于等待状态的线程，然后继续往下执行，直到执行完synchronized 代码块的代码或是中途遇到wait() ，再次释放锁。
  • notify唤醒沉睡的线程后，线程会接着上次的执行继续往下执行。所以在进行条件判断时候，可以先把 wait 语句忽略不计来进行考虑，显然，要确保程序一定要执行，并且要保证程序直到满足一定的条件再执行，要使用while来执行，以确保条件满足和一定执行。
package com.wz.code.test.thread;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

public class Container4 {

    volatile List lists = new ArrayList<>();

    public boolean add(Object o) {
        return lists.add(o);
    }

    public int size() {
        return lists.size();
    }

    public static void main(String[] args) {
        Container4 c1 = new Container4();
        // 不要使用字符串座位锁定对象
        final Object lock = new Object();

        new Thread(() -> {
            System.out.println("t2启动");
            synchronized (lock) {
                if (c1.size() != 5) {
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                lock.notify();
                System.out.println("t2结束");
            }
        }, "t2").start();

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }

        new Thread(() -> {
            System.out.println("t1启动");
            synchronized (lock) {
                for (int i = 0; i < 10; i++) {
                    c1.add(new Object());
                    System.out.println("t1 add " + i);
                    if (c1.size() == 5) {
                        lock.notify();
                        // wait释放锁, notify不释放锁
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                    try {
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                System.out.println("t1结束");
            }
        }, "t1").start();
    }
}

CountDownLatch实现线程间通信

package com.wz.code.test.thread;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

public class Container5 {

    volatile List lists = new ArrayList<>();

    public boolean add(Object o) {
        return lists.add(o);
    }

    public int size() {
        return lists.size();
    }

    public static void main(String[] args) {
        Container5 c1 = new Container5();
        CountDownLatch latch = new CountDownLatch(1);

        new Thread(() -> {
            System.out.println("t2启动");
            if (c1.size() != 5) {
                try {
                    latch.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("t2结束");
        }, "t2").start();

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }

        new Thread(() -> {
            System.out.println("t1启动");
            for (int i = 0; i < 10; i++) {
                c1.add(new Object());
                System.out.println("t1 add " + i);
                if (c1.size() == 5) {
                    latch.countDown();
                }
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            System.out.println("t1结束");
        }, "t1").start();
    }
}

在这里插入图片描述

使用ReentrantLock的Condition实现线程间通信

package com.wz.code.test.thread;

import java.util.LinkedList;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MyContainer2<T> {

    private final LinkedList<T> list = new LinkedList<>();
    private final int MAX = 10;
    private static int count = 0;

    private Lock lock = new ReentrantLock();
    private Condition producer = lock.newCondition();
    private Condition customer = lock.newCondition();

    public void put(T t) {
        lock.lock();
        try {
            while (list.size() == MAX) {
                producer.await();
            }
            list.add(t);
            ++count;
            customer.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public T get() {
        T t = null;
        lock.lock();
        try {
            while (list.size() == 0) {
                customer.await();
            }
            t = list.removeFirst();
            count--;
            producer.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
        return t;
    }

    public static void main(String[] args) {
        MyContainer2<String> c = new MyContainer2<String>();
        CountDownLatch latch = new CountDownLatch(12);
        // 10个消费者
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for (int j = 0; j < 5; j++)
                    System.out.println(Thread.currentThread().getName() + " " + c.get());
                latch.countDown();
            }, "c" + i).start();
        }
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        for (int i = 0; i < 2; i++) {
            new Thread(() -> {
                for (int j = 0; j < 25; j++)
                    c.put((Thread.currentThread().getName()) + " " + j);
                latch.countDown();
            }, "p" + i).start();
        }
        try {
            latch.await();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("程序结束: count " + count);
    }
}
悠然~
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线程间的通信
cbNotes的专栏：不积硅步，无以至千里;不积小流，无以成江海!
01-18 5万+
线程间的通信 1．线程之间的通信简介 一般而言,在一个应用程序中（即进程），一个线程往往不是孤立存在的，常常需要和其它线程通信，以执行特定的任务。如主线程和次线程，次线程与次线程，工作线程和用户界面线程等。这样,线程与线程间必定有一个信息传递的渠道。这种线程间的通信不但是难以避免的，而且在多线程编程中也是复杂和频繁的。线程间的通信涉及到4个问题： （1） 线程间如何传递信息 （2）  线程
线程间通信
dou_yuan的博客
10-29 376
线程间的通信方式主要有如下4种方式： 1）共享变量； 2）wait, notify机制； 3）Lock, Condition机制； 4）管道 下面将逐一讲解这4中线程间通信方式。 1. 共享变量 线程之间通过共享一个对象，在同步块中访问该对象中数据来实现通信。 下面是一个例子，创建了两个线程thread1和thread2，创建了Runnable实现类对象task，thr
多线程实现互相通信
NMSL6666的博客
07-09 136
再多线程开启之前首先建立两个输入输出流，并且将两者建立连接之后开启两个线程，这个时候两个线程之间就能通过管道之间的流传输数据。这样两个线程之间就建立了通信。 转载于:https://www.cnblogs.com/Eilen/p/9282366.html...
Linux下多线程间通信
09-14
在Linux环境下，多线程间通信是实现并发执行任务并协调数据访问的关键技术。线程间的通信主要通过共享内存和同步机制来实现，因为线程天然具有共享数据结构的能力，这意味着全局变量可以在多个线程之间共享。然而，...
操作系统中多线程之间通信
12-21
操作系统中的多线程通信是并发编程中的核心概念，它允许不同的执行线程在共享资源时进行协调和数据交换。在本文中，我们将深入探讨多线程通信的重要性、常见方法以及如何解决经典的问题——读者写者问题。 首先，多...
qt object多线程- 串口通信
03-13
在Qt框架中，多线程和串口通信是两个重要的技术点，它们在开发复杂的桌面应用或设备控制软件时尤其常见。本篇文章将深入探讨如何在Qt中利用对象的继承方式实现多线程来处理串口通信任务。 首先，我们要理解Qt中的多...
多线程之间通信.docx
06-04
【标题】: 多线程之间通信 【描述】: 本文档主要探讨了多线程技术在实际应用中如何处理线程间的通信和同步问题，通过实例展示了如何利用多线程实现数字排序。 【标签】: 网络 网络 cs 【正文】: 在计算机科学中...
Java多线程-线程间的通信
最新发布
02-02
这种机制被称为**等待-唤醒机制**，它是实现线程间通信的核心。 ##### （2）等待唤醒机制 等待唤醒机制是一种用于线程间协作的机制。它允许一个线程等待特定条件发生（通过调用`wait()`方法），并在条件满足时由...
python3多线程间通信
12-03
Python3多线程间通信可以使用Queue模块来实现。Queue是Python标准库中的线程安全的队列，可以用来在多个线程之间安全地传递数据。下面是一个使用Queue实现多线程间通信的例子： ```python import threading import queue def producer(q): for i in range(5): q.put(i) print("生产者生产了数据：", i) # 模拟生产数据的时间 time.sleep(1) def consumer(q): while True: data = q.get() if data is None: break print("消费者消费了数据：", data) # 模拟处理数据的时间 time.sleep(2) if __name__ == '__main__': q = queue.Queue() t1 = threading.Thread(target=producer, args=(q,)) t2 = threading.Thread(target=consumer, args=(q,)) t1.start() t2.start() t1.join() q.put(None) t2.join() ``` 在这个例子中，我们创建了一个Queue对象，然后创建了一个生产者线程和一个消费者线程。生产者线程不断地向队列中添加数据，消费者线程不断地从队列中取出数据并进行处理。当生产者线程生产完所有数据后，向队列中添加一个None，表示数据已经全部生产完毕。消费者线程在取出None后，退出循环，结束线程。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值