多线程：JAVA线程通信的方法收集

最新推荐文章于 2024-09-05 20:18:24 发布

IloveAgile

最新推荐文章于 2024-09-05 20:18:24 发布

阅读量2.1k

点赞数

分类专栏： 2.编程和产品应用文章标签：多线程 java thread class string 产品

本文链接：https://blog.csdn.net/IloveAgile/article/details/5687115

版权

2.编程和产品应用专栏收录该内容

16 篇文章 0 订阅

订阅专栏

方法一:通过访问共享变量方式（需处理同步问题）

方法一a)通过内部类实现线程的共享变量
问题：循环过度，浪费资源
代码如下:

/**
* 通过内部类实现线程的共享变量
*
*/
public class Innersharethread {
    public static void main(String[] args) {
        Mythread mythread = new Mythread();
        mythread.getThread().start();
        mythread.getThread().start();
        mythread.getThread().start();
        mythread.getThread().start();
    }
}
class Mythread {
    int index = 0;

    private class InnerThread extends Thread {
        public synchronized void run() {
            while (true) {
                System.out.println(Thread.currentThread().getName()
                        + "is running and index is " + index++);
            }
        }
    }

    public Thread getThread() {
        return new InnerThread();
    }
}

方法一b)通过实现Runnable接口实现线程的共享变量
代码如下

Java代码
/**
* 通过实现Runnable接口实现线程的共享变量
* @author Administrator
*
*/
public class Interfacaesharethread {
public static void main(String[] args) {
Mythread mythread = new Mythread();
new Thread(mythread).start();
new Thread(mythread).start();
new Thread(mythread).start();
new Thread(mythread).start();
}
}

/* 实现Runnable接口 */
class Mythread implements Runnable {
int index = 0;

public synchronized void run() {
while (true)
System.out.println(Thread.currentThread().getName()
+ "is running and the index is " + index++);
}
}

方法二: 通过管道流
问题：只能实现1对1的生产消费。
代码如下

import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;

public class CommunicateWhitPiping {
public static void main(String[] args) {
  /**
   * 创建管道输出流
   */
  PipedOutputStream pos = new PipedOutputStream();
  /**
   * 创建管道输入流
   */
  PipedInputStream pis = new PipedInputStream();
  try {
   /**
    * 将管道输入流与输出流连接此过程也可通过重载的构造函数来实现
    */
   pos.connect(pis);
  } catch (IOException e) {
   e.printStackTrace();
  }
  /**
   * 创建生产者线程
   */
  ProducerPipe p = new ProducerPipe(pos);
  /**
   * 创建消费者线程
   */
  ConsumerPipe c1 = new ConsumerPipe(pis);
  ConsumerPipe c2 = new ConsumerPipe(pis);
  /**
   * 启动线程
   */
  p.start();
  c1.start();
  c2.start();
}
}

/**
* 生产者线程(与一个管道输入流相关联)
*
*/
class ProducerPipe extends Thread {
private PipedOutputStream pos;

public ProducerPipe(PipedOutputStream pos) {
this.pos = pos;
}

public void run() {
  int i = 8;
  try {
   System.out.println(Thread.currentThread().getName() + " sending i " );
   pos.write(i);
   System.out.println(Thread.currentThread().getName() + " sent i " );
  } catch (IOException e) {
   e.printStackTrace();
  }
}
}

/**
* 消费者线程(与一个管道输入流相关联)
*
*/
class ConsumerPipe extends Thread {
private PipedInputStream pis;

public ConsumerPipe(PipedInputStream pis) {
this.pis = pis;
}

public void run() {
  try {
   System.out.println(Thread.currentThread().getName() + " reading i " );
   System.out.println(pis.read());
   System.out.println(Thread.currentThread().getName() + " read i " );
  } catch (IOException e) {
   e.printStackTrace();
  }
}
}

方法三: Wait/Notify结合共享变量
问题：
代码如下
class ShareData

{

private char c;

private boolean isProduced = false; // 信号量

public synchronized void putShareChar(char c) // 同步方法putShareChar()

{

if (isProduced) // 如果产品还未消费，则生产者等待

{

try

{

wait(); // 生产者等待

} catch (InterruptedException e) {