精华内容
下载资源
问答
  • 线程通信

    2010-11-09 10:34:29
    线程通信
  • 模仿QQ的多线程通信实例,供参考。 模仿QQ的多线程通信实例,供参考。
  • Java线程通信详解

    2020-09-01 08:37:44
    本篇文章主要介绍了Java线程通信问题,线程通信用来保证线程协调运行,有需要的朋友可以了解一下。
  • 易语言线程通信源码

    2020-07-21 10:14:19
    易语言线程通信源码,线程通信,子程序1,API_创建线程,API_等待消息,API_发送线程消息
  • 3.6 线程通信

    千次阅读 2021-02-04 00:35:31
    3.6 线程通信        线程通信是指不同线程之间相互传递信息。线程通信可以实现线程等待其他线程执行结果后再执行,这样来实现不同线程之间按照有序的方式进行工作。  &...

    3.6 线程通信

           线程通信是指不同线程之间相互传递信息。线程通信可以实现线程等待其他线程执行结果后再执行,这样来实现不同线程之间按照有序的方式进行工作。
           那么问题来了,Java要如何实现线程间通信呢?
    在这里插入图片描述


    3.6.1 实现通信–共享变量

           可以通过共享变量来实现,实现思路就是一个通过一个共享变量状态的改变来实现线程通信。下边就从代码来看下。
    在这里插入图片描述

    public class SignalDemo {
    //    private Object obj = new Object();
        boolean singal = false;
        public boolean isSingal() {
            return singal;
        }
        public void setSingal(boolean singal) {
            this.singal = singal;
        }
        public static void main(String[] args) {
            SignalDemo signalDemo = new SignalDemo();
            new Thread(()->{
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                signalDemo.setSingal(true);
                System.err.println("\r\n线程2修改信号值");
            }).start();
    
            while (!signalDemo.isSingal()){
                System.err.print("k");
            }
        }
    }
    
    

    在这里插入图片描述
           上例实现的就是一个线程工作,然后另一个线程通过改变共享变量来终止工作线程,Just it!


    3.6.2 wait-notify机制

           官方注释:wait方法可以使当前线程进入等待直到其他线程调用了对象的notify或者notifyAll方法。该方法本质上调用的是wait(0).

     * Causes the current thread to wait until another thread invokes the
     * {@link java.lang.Object#notify()} method or the
     * {@link java.lang.Object#notifyAll()} method for this object.
     * In other words, this method behaves exactly as if it simply
     * performs the call {@code wait(0)}.
    

           现在了解了wait-notify的机制后看一个小demo。用两个线程一个线程输出0-100以内的奇数,一个线程输出0-100以内的偶数。

    class SignalDemo2{
        Object myMonitorObject = new Object();
    
        public void doWait(){
            synchronized(myMonitorObject){
                try{
                    myMonitorObject.wait();
                } catch(InterruptedException e){
                    e.printStackTrace();
                }
            }
        }
    
        public void doNotify(){
            synchronized(myMonitorObject){
                myMonitorObject.notify();
            }
        }
    
        public static void main(String[] args) {
            Object o = new Object();
            AtomicInteger i= new AtomicInteger();
            new Thread(()->{
                synchronized (o){
                    while (i.get() <=100){
                        if (i.get() %2==0) {
                            System.err.println(Thread.currentThread() + ":" + i);
                            i.getAndIncrement();
                            try {
                                o.wait();
                                o.notify();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
            }).start();
    
            new Thread(()->{
                synchronized (o){
                    while (i.get() <=100){
                        if (i.get() %2!=0) {
                            System.err.println(Thread.currentThread() + ":" + i);
                            i.getAndIncrement();
                            try {
                                o.notify();
                                o.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
            }).start();
        }
    }
    

           该实现原理非常简单,当一个线程输出奇数或者偶数后,就使当前线程进入等待状态,并且通知对方操作。 注意:当使用wait-notify机制的时候不要使用String对象或者全局变量的wait方法,可能会由于String常量引用导致意想不到的结果。

    展开全文
  • 线程通信线程通信线程通信线程通信线程通信线程通信线程通信线程通信线程通信线程通信线程通信线程通信线程通信线程通信线程通信线程通信线程通信线程通信线程通信
  • 易语言源码易语言线程通信源码.rar 易语言源码易语言线程通信源码.rar 易语言源码易语言线程通信源码.rar 易语言源码易语言线程通信源码.rar 易语言源码易语言线程通信源码.rar 易语言源码易语言线程通信源码....
  • 本文主要介绍java 多线程-线程通信 这里整理了相关资料及示例代码,有兴趣的小伙伴可以参考下
  • 主要介绍了Java 线程通信的的相关资料,文中讲解非常细致,代码帮助大家更好的理解和学习,感兴趣的朋友可以了解下
  • 一客户一线程通信

    2018-09-11 15:46:07
    NetBeans工程,利用Java多线程实现客户机服务器,一客户一线程通信,通信协议为简单的Echo协议。
  • 进程线程通信,线程同步,异步,进程通信经典
  • 线程通信 为什么要线程通信?   多个线程并发执行时,在默认情况下CPU是随机切换线程的,当我们需要多个线程来共同完成一件任务,并且我们希望他们有规律的执行,那么多线程之间需要一些协调通信,以此来帮我们达到...
  • 多线程之线程通信wait和notify的使用

    千次阅读 2018-06-20 09:26:46
    线程通信

    使用wait和notify方法实现线程之间的通信,注意,这两个方法是Object类的方法,也就是说Java为所有的对象都提供的这两个方法。

    1 wait和notify必须配合synchronized关键字使用。

    2 wait方法释放锁,notify方法不释放锁。

    3 还要注意一点 就是涉及到线程之间的通信,就肯定会用到validate修饰。

    案例:
    t1线程向集合中不断添加元素,当集合中元素个数为5的时候,就向t2线程发出通知,(当集合元素个数不等于5时候,t2线程处于等待状态),然后t2向下执行,抛出异常。

    package com.wuk.Demo;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * wait和notify的使用
     * 
     * @author Administrator
     *
     */
    public class MyThread004 {
    
    
        private static volatile List list=new ArrayList();
    
        public void add() {
    
            list.add("wuk");
        }
    
        public  int size() {
    
            return list.size();
        }
    
        public static void main(String[] args) {
    
            MyThread004 list1=new MyThread004();
    
            Object obj=new Object();
    
            Thread t1=new Thread(new Runnable() {
    
                @Override
                public void run() {
    
                    synchronized (obj) {
    
                        System.out.println("t1线程启动。。。。");
                        for(int i=0;i<10;i++) {
                            list1.add();
                            System.out.println("当前线程"+Thread.currentThread().getName()+"添加了一个元素");
                            try {
                                Thread.sleep(500);
                                if(list1.size()==5) {
                                    System.out.println("已经发出通知。。");
                                    obj.notify();
                                }
    
    
                            } catch (InterruptedException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                            }
                        }
                    }
                }
            },"t1");
    
            Thread t2=new Thread (new Runnable() {
    
                @Override
                public void run() {
    
                    synchronized (obj) {
    
                        System.out.println("t2启动。。。");
                        if(list1.size()!=5) {
    
                            try {
                                obj.wait();
                            } catch (InterruptedException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                            }
                        }
                        System.out.println("当前线程:" + Thread.currentThread().getName() + "收到通知线程停止..");
                        throw new RuntimeException();
                    }
                }
            },"t2");
    
    
            t2.start();
            t1.start();
        }
    }
    

    打印结果:

    t2启动。。。
    t1线程启动。。。。
    当前线程t1添加了一个元素
    当前线程t1添加了一个元素
    当前线程t1添加了一个元素
    当前线程t1添加了一个元素
    当前线程t1添加了一个元素
    已经发出通知。。
    当前线程t1添加了一个元素
    当前线程t1添加了一个元素
    当前线程t1添加了一个元素
    当前线程t1添加了一个元素
    当前线程t1添加了一个元素
    当前线程:t2收到通知线程停止..
    Exception in thread "t2" java.lang.RuntimeException
        at com.wuk.Demo.MyThread004$2.run(MyThread004.java:79)
        at java.lang.Thread.run(Unknown Source)

    分析:
    首先启动t2线程,使得t2线程处于等待状态,然后当集合等于5的时候,t1向t2线程发出通知,但是并不会释放锁,所以当t1执行完毕后,t2线程才会向下执行。

    分析几种情况:
    (1) 有人说 validate不是可以实现线程之间的可见性吗,那么我就不需要t1通知,当t2发现集合元素是5了就会往下执行?
    去掉obj.notify(); 结果是:

    t2启动。。。
    t1线程启动。。。。
    当前线程t1添加了一个元素
    当前线程t1添加了一个元素
    当前线程t1添加了一个元素
    当前线程t1添加了一个元素
    当前线程t1添加了一个元素
    已经发出通知。。
    当前线程t1添加了一个元素
    当前线程t1添加了一个元素
    当前线程t1添加了一个元素
    当前线程t1添加了一个元素
    当前线程t1添加了一个元素
    

    分析:
    因为当t2执行了wait()方法,就会处于等待状态,如果不去唤醒他,他就会一直等待下去。

    (2)如果我们先让t1执行会是什么结果?

    t1线程启动。。。。
    当前线程t1添加了一个元素
    当前线程t1添加了一个元素
    当前线程t1添加了一个元素
    当前线程t1添加了一个元素
    当前线程t1添加了一个元素
    已经发出通知。。
    当前线程t1添加了一个元素
    当前线程t1添加了一个元素
    当前线程t1添加了一个元素
    当前线程t1添加了一个元素
    当前线程t1添加了一个元素
    t2启动。。。
    

    分析:
    因为notify不释放锁,如果t1先执行,就会先拥有锁,那么只有等到t1执行完毕以后,t2才会有机会执行,这时候集合长度早都不是5了,所以就会一直等待下去。

    展开全文
  • C# tcp多线程通信

    2016-10-23 13:39:15
    C#多线程通信的经典例子,可以充分理解多线程在socket编程中的应用
  • 线程通信读写文件

    2014-05-12 13:27:45
    线程通信读写文件代码,根据其他的代码文档修改,用于学习多线程通信
  • Java线程通信

    万次阅读 2019-08-21 23:26:20
    其实把ABC当做线程,这便是一个线程通信的例子。 wait(); 使执行的线程进行等待 notify(); 使停止的线程继续运行, join(); 使所属线程正常执行run方法,而当前线程暂时阻塞,有排队的作用 notify与no...

    我先提出一个例子
    A,B为一组,A走1米,然后 B走一米,总共100米(就是A,B轮流输出100个数)
    其实把AB当做线程,这便是一个线程通信的例子。

    wait(); 使执行的线程进行等待
    notify(); 使停止的线程继续运行,
    join(); 使所属线程正常执行run方法,而当前线程暂时阻塞,有排队的作用
    notify与notifyAll的区别
    notify方法只唤醒一个等待(对象的)线程并使该线程开始执行。所以如果有多个线程等待一个对象,这个方法只会唤醒其中一个线程,选择哪个线程取决于操作系统对多线程管理的实现。notifyAll 会唤醒所有等待(对象的)线程,尽管哪一个线程将会第一个处理取决于操作系统的实现。如果当前情况下有多个线程需要被唤醒,推荐使用notifyAll 方法。比如在生产者-消费者里面的使用,每次都需要唤醒所有的消费者或是生产者,以判断程序是否可以继续往下执行。
    线程通信主要靠的是这3个函数,但是本次例子中只使用了前2个函数,join将单独讲解。
    先看看本次例子代码如何写的

    public class C{       //记录距离
    	  int i=100;
    	  boolean flag = false; //两个线程,交替执行的一个标志
    }
    
    
    public class A implements Runnable{
    	private C c;
    	public A(C c) {
       this.c=c;
    	}
    		@Override
    		public void run() {
    		while(c.i>0) {
    			synchronized (c) {              //必须要用一把锁对象,这个对象是c
    				if(c.flag) {
    					try {
    						c.wait();           //操作wait()函数的必须和锁是同一个
    					} catch (InterruptedException e) {
    						// TODO Auto-generated catch block
    						e.printStackTrace();
    					}
    				}
         else {
    		    c.i--;
    		    System.out.println("A跑完了,还剩下"+c.i+"米");	
    		    c.flag=true;
    		    c.notify();
         }							
    			}		
    		}	
      }
    }
    
    
    public class B implements Runnable{
    	private C c;
    
    	public B(C c) {
       this.c=c;
    	}
    		@Override
    		public void run() {
    		while(c.i>0) {
    			synchronized (c) {
    				if(!c.flag) {
    					try {
    						c.wait();
    					} catch (InterruptedException e) {
    						// TODO Auto-generated catch block
    						e.printStackTrace();
    					}
    				}
         else {
    		    c.i--;
    		    System.out.println("B跑完了,还剩下"+c.i+"米");	
    		    c.flag=false;
    		    c.notify();
         }							
    			}		
    		}	
      }
    }
    
    public class Main {
    
    public static void main(String[] args) throws InterruptedException {
    C c=new C();
    A a=new A(c);
    B b=new B(c);
    Thread a1=new Thread(a);
    Thread b1=new Thread(b);
    a1.start();
    b1.start();
                                      
    	}
    }
    
    

    在这里插入图片描述
    首先我们通过锁(也必须有锁)保证了他们只有一个执行,然后通过一个执行一个停止的机制保证了他们的轮换。
    这个问题其实在线程通信中属于基础但不简单的,明白了其中的原理,在去搞其他线程通信就会容易很多的。

    展开全文
  • 主要介绍了Java编程中实现Condition控制线程通信,简单介绍了Java中控制线程通信的方法,以及对condition的解析和实例,具有一定参考价值,需要的朋友可以了解下。
  • 本文介绍C#通过接口与线程通信(捕获线程状态),并提供简单的示例代码供参考
  • socket多线程通信源码

    2010-05-21 01:00:24
    socket多线程通信源码 socket多线程通信源码
  • Qt主线程与次线程通信实例代码,方便大家学习下载使用! Qt主线程与次线程通信实例代码,方便大家学习下载使用! Qt主线程与次线程通信实例代码,方便大家学习下载使用!
  • Java线程(九):Condition-线程通信更高效的方式

    万次阅读 多人点赞 2012-04-20 14:49:39
    Lock可以更好的解决线程同步问题,使之更面向对象,并且ReadWriteLock在处理同步时更强大,那么同样,线程间仅仅互斥是不够的,还需要通信,本篇的内容是基于上篇之上,使用Lock如何处理线程通信。 那么引入本篇的...

            接近一周没更新《Java线程》专栏了,主要是这周工作上比较忙,生活上也比较忙,呵呵,进入正题,上一篇讲述了并发包下的Lock,Lock可以更好的解决线程同步问题,使之更面向对象,并且ReadWriteLock在处理同步时更强大,那么同样,线程间仅仅互斥是不够的,还需要通信,本篇的内容是基于上篇之上,使用Lock如何处理线程通信。

            那么引入本篇的主角,Condition,Condition 将 Object 监视器方法(wait、notify 和 notifyAll)分解成截然不同的对象,以便通过将这些对象与任意 Lock 实现组合使用,为每个对象提供多个等待 set (wait-set)。其中,Lock 替代了 synchronized 方法和语句的使用,Condition 替代了 Object 监视器方法的使用。下面将之前写过的一个线程通信的例子替换成用Condition实现(Java线程(三)),代码如下:

    public class ThreadTest2 {
    	public static void main(String[] args) {
    		final Business business = new Business();
    		new Thread(new Runnable() {
    			@Override
    			public void run() {
    				threadExecute(business, "sub");
    			}
    		}).start();
    		threadExecute(business, "main");
    	}	
    	public static void threadExecute(Business business, String threadType) {
    		for(int i = 0; i < 100; i++) {
    			try {
    				if("main".equals(threadType)) {
    					business.main(i);
    				} else {
    					business.sub(i);
    				}
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    		}
    	}
    }
    class Business {
    	private boolean bool = true;
    	private Lock lock = new ReentrantLock();
    	private Condition condition = lock.newCondition(); 
    	public /*synchronized*/ void main(int loop) throws InterruptedException {
    		lock.lock();
    		try {
    			while(bool) {				
    				condition.await();//this.wait();
    			}
    			for(int i = 0; i < 100; i++) {
    				System.out.println("main thread seq of " + i + ", loop of " + loop);
    			}
    			bool = true;
    			condition.signal();//this.notify();
    		} finally {
    			lock.unlock();
    		}
    	}	
    	public /*synchronized*/ void sub(int loop) throws InterruptedException {
    		lock.lock();
    		try {
    			while(!bool) {
    				condition.await();//this.wait();
    			}
    			for(int i = 0; i < 10; i++) {
    				System.out.println("sub thread seq of " + i + ", loop of " + loop);
    			}
    			bool = false;
    			condition.signal();//this.notify();
    		} finally {
    			lock.unlock();
    		}
    	}
    }

            在Condition中,用await()替换wait(),用signal()替换notify(),用signalAll()替换notifyAll(),传统线程的通信方式,Condition都可以实现,这里注意,Condition是被绑定到Lock上的,要创建一个Lock的Condition必须用newCondition()方法。

            这样看来,Condition和传统的线程通信没什么区别,Condition的强大之处在于它可以为多个线程间建立不同的Condition,下面引入API中的一段代码,加以说明。

    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;//如果写索引写到队列的最后一个位置了,那么置为0
           ++count;//个数++
           notEmpty.signal();//唤醒读线程
         } finally {
           lock.unlock();
         }
       }
    
       public Object take() throws InterruptedException {
         lock.lock();
         try {
           while (count == 0)//如果队列为空
             notEmpty.await();//阻塞读线程
           Object x = items[takeptr];//取值 
           if (++takeptr == items.length) takeptr = 0;//如果读索引读到队列的最后一个位置了,那么置为0
           --count;//个数--
           notFull.signal();//唤醒写线程
           return x;
         } finally {
           lock.unlock();
         }
       } 
     }
    

            这是一个处于多线程工作环境下的缓存区,缓存区提供了两个方法,put和take,put是存数据,take是取数据,内部有个缓存队列,具体变量和方法说明见代码,这个缓存区类实现的功能:有多个线程往里面存数据和从里面取数据,其缓存队列(先进先出后进后出)能缓存的最大数值是100,多个线程间是互斥的,当缓存队列中存储的值达到100时,将写线程阻塞,并唤醒读线程,当缓存队列中存储的值为0时,将读线程阻塞,并唤醒写线程,这也是ArrayBlockingQueue的内部实现。下面分析一下代码的执行过程:

            1. 一个写线程执行,调用put方法;

            2. 判断count是否为100,显然没有100;

            3. 继续执行,存入值;

            4. 判断当前写入的索引位置++后,是否和100相等,相等将写入索引值变为0,并将count+1;

            5. 仅唤醒读线程阻塞队列中的一个;

            6. 一个读线程执行,调用take方法;

            7. ……

            8. 仅唤醒写线程阻塞队列中的一个。

            这就是多个Condition的强大之处,假设缓存队列中已经存满,那么阻塞的肯定是写线程,唤醒的肯定是读线程,相反,阻塞的肯定是读线程,唤醒的肯定是写线程,那么假设只有一个Condition会有什么效果呢,缓存队列中已经存满,这个Lock不知道唤醒的是读线程还是写线程了,如果唤醒的是读线程,皆大欢喜,如果唤醒的是写线程,那么线程刚被唤醒,又被阻塞了,这时又去唤醒,这样就浪费了很多时间。

            本文来自:高爽|Coder,原文地址:http://blog.csdn.net/ghsau/article/details/7481142,转载请注明。

    展开全文
  • java线程通信课程设计

    2011-05-01 20:22:17
    线程通信,采用java技术,实现线程之间的通信。
  • Java 常见线程通信生产消费案例演示

    千次阅读 2020-03-18 13:02:51
    介绍了Java线程通信的原理、目的、方法,在文章最后给出了多个线程通信案例。
  • linux 多线程通信 socket

    2012-11-28 21:49:25
    linux下面的线程通信,包括unix域的线程和socket通信。
  • Java 线程通信示例 源代码 多线程之间通信,值得收藏
  • java实现线程通信的几种方式

    千次阅读 2020-05-30 19:34:35
    比如大家熟知的消息中间件的实现,从某种角度上讲,就借助了多线程通信的思想,下面总结了JDK中常用的几种实现线程通信的方式,提供参考 1、synchronized实现方式 可能很多小伙伴们会有疑问,synchronized是对共享...
  • 架构系列——线程通信的实现方式

    千次阅读 2020-02-13 20:52:13
    一、什么是线程通信? 二、线程通信的实现 1.使用volatile实现线程通信 2.使用wait/notify实现线程通信 3.使用ReentrantLock创建Condition实现 4.通过LockSupport实现线程通信 5.使用CountDownLatch实现线程...
  • Linux C 开发 线程通信 POSIX 条件变量 互斥
  • 基于VS开发环境,使用C#开发语言。C#窗体TCP/IP的Socket多线程通信,互发消息,传输文件。
  • Python使用UDP实现单线程通信

    千次阅读 2021-06-04 10:55:44
    Python使用UDP实现单线程通信 先声明一下,本人是学习web方向,这篇文章是关于我在学校学习python的时候学到一个比较有意思的东西,所以写来分享一下,并非专业python学生,不足之处欢迎指正 ! 首先我们先了解一下...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 475,893
精华内容 190,357
关键字:

线程通信