Java多线程通信:交替打印ABAB实例

使用wait()和notify()实现Java多线程通信:两个线程交替打印A和B,如ABABAB

public class Test {
  public static void main(String[] args) {
    final PrintAB print = new PrintAB();
    new Thread(new Runnable() {
      public void run(){
        for(int i=0;i<5;i++) {
          print.printA();
          }
          }
    }).start();
    new Thread(new Runnable() {
      public void run() {
        for(int i=0;i<5;i++) {
          print.printB(); }
              }
     }).start();
    }
 }
 class PrintAB{
  private boolean flag = true;
  public synchronized void printA () {
      while(!flag) {
        try {
          this.wait();
        } catch (InterruptedException e) {
          e.printStackTrace();
               } }
        System.out.print("A");
         flag = false;
         this.notify();
      }
  public synchronized void printB () {
      while(flag) {
        try {
          this.wait();
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
      System.out.print("B");
      flag = true;
      this.notify(); }
 }

补充知识:Java多个线程顺序打印数字

要求

启动N个线程, 这N个线程要不间断按顺序打印数字1-N. 将问题简化为3个线程无限循环打印1到3

方法一: 使用synchronized

三个线程无序竞争同步锁, 如果遇上的是自己的数字, 就打印. 这种方式会浪费大量的循环

public class TestSequential1 {
  private volatile int pos = 1;
  private volatile int count = 0;

  public void one(int i) {
    synchronized (this) {
      if (pos == i) {
        System.out.println("T-" + i + " " + count);
        pos = i % 3 + 1;
        count = 0;
      } else {
        count++;
      }
    }
  }

  public static void main(String[] args) {
    TestSequential1 demo = new TestSequential1();
    for (int i = 1; i <=3; i++) {
      int j = i;
      new Thread(()->{
        while(true) {
          demo.one(j);
        }
      }).start();
    }
  }
}

输出

T-1 0
T-2 5793
T-3 5285
T-1 2616
T-2 33
T-3 28
T-1 22
T-2 44
T-3 6
T-1 881
T-2 118358
T-3 247380
T-1 30803
T-2 29627
T-3 52044
...

方法二: 使用synchronized配合wait()和notifyAll()

竞争同步锁时使用wait()和notifyAll(), 可以避免浪费循环

public class TestSequential4 {
  private volatile int pos = 1;
  private volatile int count = 0;
  private final Object obj = new Object();

  public void one(int i) {
    System.out.println(i + " try");
    synchronized (obj) {
      System.out.println(i + " in");
      try {
        while (pos != i) {
          count++;
          System.out.println(i + " wait");
          obj.wait();
        }
        System.out.println("T-" + i + " " + count);
        pos = i % 3 + 1;
        count = 0;
        obj.notifyAll();
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  }

  public static void main(String[] args) {
    TestSequential4 demo = new TestSequential4();
    for (int i = 3; i >=1; i--) {
      int j = i;
      new Thread(()->{
        while(true) {
          demo.one(j);
        }
      }).start();
    }
  }
}

输出

3 try
3 in
3 wait
2 try
2 in
2 wait
1 try
1 in
T-1 2
1 try
1 in
1 wait
T-2 1
2 try
2 in
2 wait
T-3 1
3 try
3 in
3 wait
2 wait
T-1 2
1 try
1 in
1 wait
T-2 1
2 try
2 in
2 wait
T-3 1
3 try
3 in
3 wait
2 wait
T-1 2
1 try
1 in
1 wait
T-2 1
2 try
2 in
2 wait
T-3 1
3 try
3 in
3 wait
2 wait
T-1 2
1 try
1 in
1 wait
T-2 1
2 try
2 in
2 wait
T-3 1
3 try
3 in
3 wait
2 wait
T-1 2
1 try
1 in
1 wait
T-2 1
2 try
2 in
2 wait
T-3 1
3 try
3 in
3 wait
2 wait
T-1 2
1 try
1 in
1 wait
T-2 1
2 try
2 in
2 wait
T-3 1
3 try
3 in
3 wait
2 wait
T-1 2
1 try
1 in
1 wait
T-2 1
2 try
2 in
2 wait
T-3 1
3 try
3 in
3 wait
2 wait
T-1 2
1 try
1 in
1 wait
T-2 1
2 try
2 in
2 wait
T-3 1
3 try
3 in
3 wait
2 wait
T-1 2
1 try
1 in
1 wait
T-2 1
2 try
2 in
2 wait
T-3 1
3 try
3 in
3 wait
2 wait
T-1 2
...

方法三: 使用可重入锁

用Lock做, 非公平锁, 三个线程竞争, 如果遇上的是自己的数字, 就打印. 这种方式也会浪费大量的循环

public class TestSequential2 {
  private final Lock lock = new ReentrantLock();
  private volatile int pos = 1;
  private volatile int count = 0;

  public void one(int i) {
    lock.lock();
    if (pos == i) {
      System.out.println("T-" + i + " " + count);
      pos = i % 3 + 1;
      count = 0;
    } else {
      count++;
    }
    lock.unlock();
  }

  public static void main(String[] args) {
    TestSequential2 demo = new TestSequential2();
    for (int i = 1; i <=3; i++) {
      int j = i;
      new Thread(()->{
        while(true) {
          demo.one(j);
        }
      }).start();
    }
  }
}

输出

T-1 0
T-2 0
T-3 323
T-1 54
T-2 68964
T-3 97642
T-1 6504
T-2 100603
T-3 6989
T-1 1313
T-2 0
T-3 183741
T-1 233
T-2 5081
T-3 164367
..

方法四: 使用可重入锁, 启用公平锁

和3一样, 但是使用公平锁, 这种情况下基本上可以做到顺序执行, 偶尔会产生多一次循环

private final Lock lock = new ReentrantLock(true);

输出

T-1 0
T-2 0
T-3 0
T-1 0
T-2 0
T-3 0
T-1 0
T-2 0
T-3 0
T-1 0
T-2 0
T-3 1
T-1 1
T-2 1
T-3 1
...

方法五: 使用Condition

每个线程如果看到不是自己的计数, 就await(), 如果是自己的计数, 就完成打印动作, 再signalAll()所有其他线程去继续运行, 自己在下一个循环后, 即使又继续执行, 也会因为计数已经变了而await.

如果ReentrantLock构造参数使用true, 可以基本消除 ~await 这一步的输出.

public class ReentrantLockCondition2 {
  private static Lock lock = new ReentrantLock();
  private static Condition condition = lock.newCondition();
  private volatile int state = 1;

  private void handle(int state) {
    lock.lock();
    try {
      while(true) {
        while(this.state != state) {
          System.out.println(state + " ~await");
          condition.await();
        }
        System.out.println(state);
        this.state = state % 3 + 1;
        condition.signalAll();
        System.out.println(state + " await");
        condition.await();
      }
    } catch (InterruptedException e) {
      e.printStackTrace();
    } finally {
      lock.unlock();
    }
  }

  public static void main(String[] args) {
    ReentrantLockCondition2 rlc = new ReentrantLockCondition2();
    new Thread(()->rlc.handle(1)).start();
    new Thread(()->rlc.handle(2)).start();
    new Thread(()->rlc.handle(3)).start();
  }
}

方法六: 使用多个Condition

给每个线程不同的condition. 这个和4的区别是, 可以用condition.signal()精确地通知对应的线程继续执行(在对应的condition上await的线程, 可能是多个). 这种情况下是可以多个线程都不unlock锁的情况下进行协作的. 注意下面的while(true)循环是在lock.lock()方法内部的.

public class ReentrantLockCondition {
  private static Lock lock = new ReentrantLock();
  private static Condition[] conditions = {lock.newCondition(), lock.newCondition(), lock.newCondition()};
  private volatile int state = 1;

  private void handle(int state) {
    lock.lock();
    try {
      while(true) {
        while(this.state != state) {
          conditions[state - 1].await();
        }
        System.out.println(state);
        this.state = state % 3 + 1;
        conditions[this.state - 1].signal();
        conditions[state - 1].await();
      }
    } catch (InterruptedException e) {
      e.printStackTrace();
    } finally {
      lock.unlock();
    }
  }

  public static void main(String[] args) {
    ReentrantLockCondition rlc = new ReentrantLockCondition();
    new Thread(()->rlc.handle(1)).start();
    new Thread(()->rlc.handle(2)).start();
    new Thread(()->rlc.handle(3)).start();
  }
}

以上这篇Java多线程通信:交替打印ABAB实例就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持我们。

(0)

相关推荐

  • java多线程编程实例

    一.相关知识: Java多线程程序设计到的知识: (一)对同一个数量进行操作 (二)对同一个对象进行操作 (三)回调方法使用 (四)线程同步,死锁问题 (五)线程通信 等等 二.示例一:三个售票窗口同时出售20张票; 程序分析: 1.票数要使用同一个静态值 2.为保证不会出现卖出同一个票数,要java多线程同步锁. 设计思路: 1.创建一个站台类Station,继承Thread,重写run方法,在run方法里面执行售票操作!售票要使用同步锁:即有一个站台卖这张票时,其他站台要等这张票卖完! 2.

  • Java实现多线程轮流打印1-100的数字操作

    首先打印1-100数字如果用一个单线程实现那么只要一个for循环即可,那么如果要用两个线程打印出来呢?(一个线程打印奇数,一个线程打印偶数)于是大家会想到可以通过加锁实现,但是这样的效率是不是不高?这里我用一个变量来控制两个线程的输出 public class ThreadTest { volatile int flag=0; public void runThread() throws InterruptedException{ Thread t1=new Thread(new Thread1

  • Java常见面试题之多线程和高并发详解

    volatile 对 volatile的理解 volatile 是一种轻量级的同步机制. 保证数据可见性 不保证原子性 禁止指令重排序 JMM JMM(Java 内存模型)是一种抽象的概念,描述了一组规则或规范,定义了程序中各个变量的访问方式. JVM运行程序的实体是线程,每个线程创建时 JVM 都会为其创建一个工作内存,是线程的私有数据区域.JMM中规定所有变量都存储在主内存,主内存是共享内存.线程对变量的操作在工作内存中进行,首先将变量从主内存拷贝到工作内存,操作完成后写会主内存.不同线程间

  • Java多线程通信:交替打印ABAB实例

    使用wait()和notify()实现Java多线程通信:两个线程交替打印A和B,如ABABAB public class Test { public static void main(String[] args) { final PrintAB print = new PrintAB(); new Thread(new Runnable() { public void run(){ for(int i=0;i<5;i++) { print.printA(); } } }).start(); n

  • java多线程之火车售票系统模拟实例

    1.前言 为了学习多线程共享与通信,我们模拟一个火车售票系统,假设有10张火车票,三个窗口(也就是三个线程)同时进行售票. 2.非同步代码 package com.tl.skyLine.thread; /** * Created by tl on 17/3/6. */ public class SellTicket { public static void main(String[] args) { TicketWindow tw = new TicketWindow(); Thread t1

  • JAVA多线程实现生产者消费者的实例详解

    JAVA多线程实现生产者消费者的实例详解 下面的代码实现了生产者消费者的问题 Product.Java package consumerProducer; public class Product { private String id; public String getId() { return id; } public void setId(String id) { this.id = id; } public Product(String id) { this.id=id; } publ

  • Java多线程通信实现方式详解

    这篇文章主要介绍了Java多线程通信实现方式详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 线程通信的方式: 1.共享变量 线程间通信可以通过发送信号,发送信号的一个简单方式是在共享对象的变量里设置信号值.线程A在一个同步块里设置boolean型成员变量hasDataToProcess为true,线程B也在同步代码块里读取hasDataToProcess这个成员变量.这个简单的例子使用了一个持有信号的对象,并提供了set和get方法. pu

  • java实现两个线程交替打印的实例代码

    使用ReentrantLock实现两个线程交替打印 实现字母在前数字在后 package com.study.pattern; import java.util.concurrent.CountDownLatch; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public c

  • Java多线程通信问题深入了解

    目录 概述 引入 加入线程安全 实现生产者与消费者问题 总结 概述 多线程通信问题,也就是生产者与消费者问题 生产者和消费者为两个线程,两个线程在运行过程中交替睡眠,生产者在生产时消费者没有在消费,消费者在消费时生产者没有在生产,确保数据安全 以下为百度百科对于该问题的解释: 生产者与消费者问题: 生产者消费者问题(Producer-consumer problem),也称有限缓冲问题(Bounded-buffer problem),是一个多线程同步问题的经典案例.该问题描述了两个共享固定大小缓

  • java UDP通信客户端与服务器端实例分析

    本文实例讲述了java UDP通信客户端与服务器端.分享给大家供大家参考,具体如下: 最初Udp是以字节为单位进行传输的,所以有很大的限制 服务器端: import java.net.*; public class TestUdpServer { public static void main(String[] args) throws Exception { byte[] buf = new byte[1024]; DatagramPacket dp = new DatagramPacket(

  • java Tcp通信客户端与服务器端实例

    本文实例讲述了java Tcp通信客户端与服务器端.分享给大家供大家参考,具体如下: 由服务器端发送数据 服务器端: import java.io.*; import java.net.*; public class TestSocket { public static void main(String[] args) { try { ServerSocket ss = new ServerSocket(8888); while(true) { Socket s = ss.accept(); O

  • Python多线程通信queue队列用法实例分析

    本文实例讲述了Python多线程通信queue队列用法.分享给大家供大家参考,具体如下: queue: 什么是队列:是一种特殊的结构,类似于列表.不过就像排队一样,队列中的元素一旦取出,那么就会从队列中删除. 线程之间的通信可以使用队列queue来进行 线程如何使用queue.Queue[还有其他类型的对象下面讲]来通信: 1.创建一个Queue对象:对象=queue.Queue(x),x是队列容量,x可以不填,默认没有容量限制, 2.get()可以使线程从队列中获取一个元素,如果队列为空,ge

  • Java多线程通信wait()和notify()代码实例

    1.wait()方法和sleep()方法: wait()方法在等待中释放锁:sleep()在等待的时候不会释放锁,抱着锁睡眠. 2.notify(): 随机唤醒一个线程,将等待队列中的一个等待线程从等待队列中移到同步队列中. 代码如下 public class Demo_Print { public static void main(String[] args) { Print p = new Print(); new Thread() { public void run() { while (

随机推荐