线程通信

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

其中方法一有两种实现方法,即
方法一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();   
    }   
}  

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

# 方法二:  
# 代码如下 

# 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();      
# }      
# }      
# }     

评论

1 楼 puhaier 2012-02-03