一、线程间通讯
其实就是多个线程在操作同一个资源,但是操作的动作不同。
- 例如有一个资源,包含name sex信息
- 一个输入线程要对其进行赋值
- 一个输出线程要对其进行打印
- 发现用两个线程来分别执行input(存姓名,性别)和output(取姓名,性别)时,会出现安全问题,出现人妖
- 那么让两个线程的动作同步(synchronized)来解决,都加同一把锁(object),这样在某一刻时间,就只能有一个线程能操作资源,貌似解决了问题
- 但是又发现,不能达到输入一个就输出一个,而是成片的输入,成片的输出
- 这时,就考虑加个判断flag,
- 当flag为false代表资源为空可以输入数据,
- 输入完数据后,唤醒output,让flag=true,然后让input wait 释放资源和锁,并等待,
- output输出数据,完成后让flag=false,唤醒input,output wait释放资源和锁。。。。。。
- 这就是多线程的等待唤醒机制
二、常用方法
public class Object
{
//1、唤醒在此对象监视器上等待的单个线程。对象监视器相当于锁
public final native void notify();
//2、唤醒在此对象监视器上等待的所有线程。
public final native void notifyAll();
//3、在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前,导致当前线程等待。
public final void wait() throws InterruptedException
{
wait(0);
}
//在其他线程调用此对象的 notify() 方法或 notifyAll() 方法,或者超过指定的时间量前,导致当前线程等待。
public final native void wait(long timeout) throws InterruptedException;
}
这三种方法都定义在Object类中,为什么呢?
- 这些方法全用在同步中(因为要对持有监视器《锁》的线程操作,所以要使用在同步中,因为只有同步才具有锁)
- 使用这些方法必须要标识所属的同步的锁=》obj.wait(); obj.notify(); obj.notifyall();
- 也可以说:这些方法在操作同步中线程时,都必须要标识它们所操作线程持有的锁:也就是说等待和唤醒必须是同一个锁
- 锁可以是任意对象,所以任意对象调用的方法一定定义在Object类中
三、示例
//资源类
class Res
{
String name;
int age;
//因为要先输入,所以初始化为false
boolean flag = false;
//设置资源信息
public synchronized void setRes(String name,int age)
{
if(flag)
try{wait();}catch(Exception e){}
this.name = name;
this.age = age;
flag = true;
notify();
}
//打印资源信息
public synchronized void out()
{
if(!flag)
try{wait();}catch(Exception e){}
System.out.println(name+"----"+age);
flag = false;
notify();
}
}
//输入
class Input implements Runnable
{
Res res = new Res();
Input(Res res)
{
this.res = res;
}
boolean flag = true;
public void run()
{
while(true)
{
if(flag)
{
res.setRes("java",20);
}
else
{
res.setRes("丽丽",18);
}
flag = !flag;
}
}
}
//输出
class Output implements Runnable
{
Res res = new Res();
Output(Res res)
{
this.res = res;
}
public void run()
{
while(true)
{
res.out();
}
}
}
//测试
class Test
{
public static void main(String[] args)
{
Res res = new Res();
Input in = new Input(res);
Output out = new Output(res);
new Thread(in).start();
new Thread(out).start();
new Thread(in).start();
new Thread(out).start();
}
}
四、wait() 和sleep() 的区别:
- wait():释放资源,释放锁,是锁的方法
- sleep():释放资源,不释放锁,是Thread的方法
- wait:可以指定时间也可以不指定时间。不指定时间,只能由对应的notify或者notifyAll来唤醒。
- sleep:必须指定时间,时间到自动从冻结状态转成运行状态(临时阻塞状态)。
五、生产者消费者示例
class ProducerConsumerDemo
{
public static void main(String[] args)
{
Resource res = new Resource();
Producer pro = new Producer(res);
ConsumerDemo con = new ConsumerDemo(res);
new Thread(pro).start();
new Thread(pro).start();
new Thread(con).start();
new Thread(con).start();
}
}
class Resource
{
String name;
int count = 0;
boolean flag = false;
public synchronized void setRes(String name)
{
while(flag)
try{wait();}catch(Exception e){}
this.name = name + "---" + count++;
System.out.println(Thread.currentThread().getName()+"---生产:"+this.name);
flag = true;
notifyAll();
}
public synchronized void out()
{
while(!flag)
try{wait();}catch(Exception e){}
System.out.println(Thread.currentThread().getName()+"--------------消费:"+name);
flag = false;
notifyAll();
}
}
class Producer implements Runnable
{
Resource res = new Resource();
Producer(Resource res)
{
this.res = res;
}
public void run()
{
while(true)
res.setRes("商品");
}
}
class ConsumerDemo implements Runnable
{
Resource res = new Resource();
ConsumerDemo(Resource res)
{
this.res = res;
}
public void run()
{
while(true)
res.out();
}
}
六、jdk1.5升级版的生产者消费者示例
//java.util.concurrent.locks.Lock
class interface Lock
{
//1,获取锁
void lock();
//2,释放锁。
void unlock();
//3,返回绑定到此 Lock 实例的新 Condition 实例
Condition newCondition();
}
- 锁是控制多个线程对共享资源进行访问的工具。
- Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。
- 此实现允许更灵活的结构,可以具有差别很大的属性,可以支持多个相关的 Condition 对象。
//一个可重入的互斥锁 Lock,它具有与使用 synchronized 方法和语句所访问的隐式监视器锁相同的一些基本行为和语义,但功能更强大。
//ReentrantLock 将由最近成功获得锁,并且还没有释放该锁的线程所拥有。
//当锁没有被另一个线程所拥有时,调用 lock 的线程将成功获取该锁并返回。
public class ReentrantLock implements Lock, java.io.Serializable
{
private static final long serialVersionUID = 7373984872572414699L;
//构造方法:创建一个 ReentrantLock 的实例。
public ReentrantLock() {
sync = new NonfairSync();
}
//构造方法:创建一个具有给定公平策略的 ReentrantLock。
public ReentrantLock(boolean fair) {
sync = (fair)? new FairSync() : new NonfairSync();
}
//方法主要用到Lock的lock()和unlock();
}
//java.util.concurrent.locks.Condition
//Condition 将 Object 监视器方法(wait、notify 和 notifyAll)分解成截然不同的对象,
//以便通过将这些对象与任意 Lock 实现组合使用,为每个对象提供多个等待 set(wait-set)。
//其中,Lock 替代了 synchronized 方法和语句的使用,Condition 替代了 Object 监视器方法的使用
//Condition 实例实质上被绑定到一个锁上。要为特定 Lock 实例获得 Condition 实例,请使用其 newCondition() 方法。
public interface Condition
{
//造成当前线程在接到信号或被中断之前一直处于等待状态。
void await() throws InterruptedException;
//造成当前线程在接到信号、被中断或到达指定等待时间之前一直处于等待状态
boolean await(long time, TimeUnit unit) throws InterruptedException;
//唤醒一个等待线程。
void signal();
//唤醒所有等待线程。
void signalAll();
}
import java.util.concurrent.locks.*;
class ProducerConsumerDemo1
{
public static void main(String[] args)
{
Resource res = new Resource();
Producer pro = new Producer(res);
ConsumerDemo con = new ConsumerDemo(res);
new Thread(pro).start();
new Thread(pro).start();
new Thread(con).start();
new Thread(con).start();
}
}
class Resource
{
private String name;
private int count = 0;
private boolean flag = false;
Lock lock = new ReentrantLock();
Condition condition_pro = lock.newCondition();
Condition condition_con = lock.newCondition();
public void setRes(String name)throws InterruptedException
{
lock.lock();
try
{
while(flag)
condition_pro.await();
this.name = name + "---" + count++;
System.out.println(Thread.currentThread().getName()+"---生产:"+this.name);
flag = true;
condition_con.signal();
}
finally
{
lock.unlock();
}
}
public void out()throws InterruptedException
{
lock.lock();
try
{
while(!flag)
condition_con.await();
System.out.println(Thread.currentThread().getName()+"--------------消费:"+name);
flag = false;
condition_pro.signal();
}
finally
{
lock.unlock();
}
}
}
class Producer implements Runnable
{
Resource res = new Resource();
Producer(Resource res)
{
this.res = res;
}
public void run()
{
try
{
while(true)
res.setRes("商品");
}
catch (InterruptedException e)
{
}
}
}
class ConsumerDemo implements Runnable
{
Resource res = new Resource();
ConsumerDemo(Resource res)
{
this.res = res;
}
public void run()
{
try
{
while(true)
res.out();
}
catch (InterruptedException e)
{
}
}
}
- JDK1.5中提供了多线程升级解决方案
- 将同步Synchronized替换成Lock
- 将Object中的wait,notify,notifyAll,替换成了Condition对象,该对象可以通过Lock锁获取
- 该示例中实现了本方只唤醒对方的操作
七、怎样停止线程?
只有一种方法,让run方法结束。
- 定义循环结束标记:因为多线程运行代码一般都是循环,只要控制了循环即可让run方法结束,也就是线程结束
- 如果线程处于了冻结状态,是不可能读到标记的,使用Thread类提供的interrupt方法:该方法是结束线程的冻结状态,让线程回到运行状态中来
-
public class Thread
{
//注:stop方法已经过时不再使用
//如果线程在调用 Object 类的 wait()方法,或者该类的 join(),sleep(long) 等方法过程中受阻,
//则其中断状态将被清除,wait等方法会抛出一个 InterruptedException异常,那么在catch块中可以更改标记结束循环
public void interrupt()
{}
}
分享到:
相关推荐
C++ 多线程编程之三----线程间通讯 C++ 多线程编程中,线程间通讯是非常重要的一部分。线程间通讯可以让不同的线程之间进行信息传递,实现协作和同步。在多线程编程中,线程间通讯可以使用全局变量、自定义消息等...
jeromq-0.3.5.jar 线程间通讯
在"JAVA100例之实例64 JAVA线程间通讯"这个主题中,我们将深入探讨Java中实现线程间通信的几种主要方法。 1. **共享数据**:最直观的线程间通信方式是通过共享内存空间,即共享变量。只要对共享变量的操作是线程...
标题与描述均提到了“多线程编程之三——线程间通讯”,这明确指出了文章的核心主题:在多线程编程环境下,不同线程之间的通信机制。在现代软件开发中,尤其是涉及到高性能计算、并发处理以及分布式系统设计时,线程...
在Android系统中,线程间通信(Inter-Thread Communication,简称ITC)是应用程序开发中的重要环节,尤其在处理耗时操作或者优化UI性能时显得至关重要。线程间通信允许不同线程之间交换数据和执行任务,以确保主线程...
在Windows操作系统的发展历程中,Windows 2000作为一代经典,其提供的线程间通信机制对于开发多线程应用程序起到了重要的作用。线程间通信是指在操作系统中,同一进程或不同进程的线程之间能够互相交换信息的能力。...
4. **线程间通信**:线程间通信允许线程之间交换信息,Java提供了多种机制,如`wait()`, `notify()`, `notifyAll()`,Python中则有`Condition`对象。 5. **线程休眠**:Java的`Thread.sleep()`方法可以让线程暂停...
下面我们将围绕标题“线程间通讯”和描述“通过代码实现线程间通讯,实现等待、唤醒等机制”来深入讲解相关知识点。 1. **线程的基本概念**: - **线程**是操作系统分配处理器时间的基本单位,一个进程中可以有多...
Windows 2000提供的常用对象可分成三类:核心应用服务、线程同步和线程间通讯。其中,开发人员可以使用线程同步对象来协调线程和进程的工作,以使其共享信息并执行任务。此类对象包括互锁数据、临界段、事件、互斥体...
本文介绍多线程间通讯的基本知识,并带有源代码。
在软件开发中,尤其是涉及到图形用户界面(GUI)的应用程序,界面线程和工作线程之间的通讯是一个重要的设计环节。界面线程,通常被称为主线程,负责处理用户交互和更新UI,而工作线程则用于执行耗时的操作,避免...
在Windows编程环境中,线程间通信(Inter-Thread Communication,ITC)是多线程应用程序中必不可少的一部分。本文将深入探讨如何在Visual C++中利用自定义消息来实现实现线程间的通信,并通过一个小型实例来阐述这一...
在“Qt多线程通讯”DEMO中,主线程可能创建了一个`QThread`实例,并启动它。接着,一个工作对象(可能是自定义的QObject派生类)被移动到子线程中。这个工作对象可能会有一个接收参数的槽函数,用于处理主线程传递...
5. **线程安全**: - 在多线程环境中,数据共享是需要特别注意的问题。消息传递可以作为避免数据竞争的一种手段,因为每个线程通过消息队列顺序地接收和处理消息,而不是直接访问共享数据。 - 但需要注意的是,...
在Windows Forms(WinForm)应用程序中,经常遇到需要在后台线程执行耗时操作,如数据处理、网络请求等,而这些操作的结果需要更新到用户界面...实践中,根据项目的具体需求和复杂性,可以选择最适合的线程通讯方案。
Java中的线程间通信是多线程编程中的关键部分,以确保不同线程之间的协作和数据交换。在Java中,管道(Pipe)流提供了一种有效的方法,允许数据从一个线程传递到另一个线程,从而实现线程间的通信。管道通常由两个流...
采用的是C#的Winform开发,提供了两种线程交互的方式。 第一:在主线程中开启两个子线程,子线程用事件方式来进行通信。对于主线程的控件操作采用的是delegate委托的方式,避免主线程假死。 第二:采用的是...
c#编写串口通讯代码多线程实现,逻辑与界面分离。发送与接收都为单独线程
本资源包“多线程之间通讯5.rar”显然关注的是如何在多线程环境下实现线程间的通信。 线程之间的通信(IPC, Inter-Process Communication)是为了协调不同线程间的工作,确保数据的一致性和正确性。以下是一些主要...