java间的线程通信

不同线程间进行通信通常有两种简单方法:
方法一 通过访问共享变量的方式(注:需要处理同步问题)
方法二 通过管道流

其中方法一有两种实现方法,即
方法一a)通过内部类实现线程的共享变量
代码如下:
Java代码
/** 
* 通过内部类实现线程的共享变量 
* 
*/ 
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();  
    }  
} 

/**
* 通过内部类实现线程的共享变量
*
*/
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++);   
}   
}  

/**
* 通过实现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++);
}
}
方法二:
代码如下
Java代码
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();   
}   
/**  
* 创建生产者线程  
*/   
Producer p = new Producer(pos);   
/**  
* 创建消费者线程  
*/   
Consumer c = new Consumer(pis);   
/**  
* 启动线程  
*/   
p.start();   
c.start();   
}   
}   
 
/**  
* 生产者线程(与一个管道输入流相关联)  
*  
*/   
class Producer extends Thread {   
private PipedOutputStream pos;   
public Producer(PipedOutputStream pos) {   
this.pos = pos;   
}   
public void run() {   
int i = 8;   
try {   
pos.write(i);   
} catch (IOException e) {   
e.printStackTrace();   
}   
}   
}   
 
/**  
* 消费者线程(与一个管道输入流相关联)  
*  
*/   
class Consumer extends Thread {   
private PipedInputStream pis;   
public Consumer(PipedInputStream pis)   
{   
this.pis = pis;   
}   
public void run() {   
try {   
System.out.println(pis.read());   
} catch (IOException e) {   
e.printStackTrace();   
}   
}   
}