Java多线程-线程间的通信

package Thread;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.TimeUnit;

public class waitNotify {
	//标志
	static boolean flag = true;
	//被锁住的对象
	static Object lock = new Object();
	public static void main(String[] args) {
		Thread waiThread = new Thread(new Wait(),"WaitThread");
		waiThread.start();
		try {
			TimeUnit.SECONDS.sleep(1);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		Thread notifyThread = new Thread(new Notify(),"Notify");
		notifyThread.start();
		
	}
	static class Wait implements Runnable{
		@Override
		public void run() {
			// TODO Auto-generated method stub
			
			synchronized (lock) {
				while(flag) {
					System.out.println(Thread.currentThread()+"flag is true. Wait Method start:"
							+ new SimpleDateFormat("HH:mm:ss").format(new Date())
							);
					//调用wait，释放锁，这个线程进入等待队列
					try {
						lock.wait();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				System.out.println(Thread.currentThread()+" flag is false. Notify执行完毕！这个线程也从wait方法返回了"
						+new SimpleDateFormat("HH:mm:ss").format(new Date()));
				
			}
		}
	}
	static class Notify implements Runnable{
		@Override
		public void run() {
			// TODO Auto-generated method stub
			synchronized (lock) {
				//获取到了lock的锁，执行notify时，不会释放lock锁
				//这个线程执行完锁块内的代码才释放锁
				System.out.println(Thread.currentThread()+"  Notify线程得到锁了"+new SimpleDateFormat("HH:mm:ss").format(new Date()));
				//通知等待队列中的线程，让他们进入同步队列
				lock.notifyAll();
				flag = false;
				try {
					Thread.sleep(2000);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			//上面这个锁执行完后，释放锁，执行完后，同步队列中的线程可能会去获得锁
			//而这个线程可能会被调度进入就绪队列，可能不会执行后面的，让另一个线程去执行了
			
			//再次获得执行机会，也可能根本一直是这个线程在运行，再次获得一个锁
			synchronized (lock) {
				System.out.println(Thread.currentThread()+"这个线程再次获得锁"+new SimpleDateFormat("HH:mm:ss").format(new Date()));
				
			}
		}
	}
}

package Thread;

import java.io.IOException;
import java.io.PipedReader;
import java.io.PipedWriter;

public class piped {
	public static void main(String[] args) {
		PipedWriter outPipedWriter = new PipedWriter();
		PipedReader inPipedReader = new PipedReader();
		try {
			//将这个pipe的两端连接起来，如果不连接，使用一端时会出错
			outPipedWriter.connect(inPipedReader);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		//创建一个线程，从而这个线程可以对
		Thread pringThread = new Thread(new Print(inPipedReader), "PrintThread");
		pringThread.start();
		int receive = 0;
		try {
			while((receive = System.in.read()) != -1) {
				outPipedWriter.write(receive);
			}
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			try {
				outPipedWriter.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
	static class Print implements Runnable{
		private PipedReader inPipedReader;
		public Print(PipedReader in) {
			this.inPipedReader = in;
		}
		@Override
		public void run() {
			// TODO Auto-generated method stub
			int receive = 0;
			try {
				while((receive = inPipedReader.read()) != -1) {
					System.out.print((char)receive );
				}
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

Join

package Thread;

import java.util.concurrent.TimeUnit;

public class joinTest {
	public static void main(String[] args) {
		Thread previousThread = Thread.currentThread();
		for(int i=0;i<10;i++) {
			//每个线程拥有前一个线程的引用，知道线程
			Thread thread = new Thread(new Domino(previousThread), String.valueOf(i));
			thread.start();
			previousThread = thread;
		}
		try {
			TimeUnit.SECONDS.sleep(5);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName()+" terminated.");
	}
	static class Domino implements Runnable{
		private Thread rThread;
		public Domino(Thread thread) {
			this.rThread = thread;
		}
		@Override
		public void run() {
			// TODO Auto-generated method stub
			try {
				rThread.join();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}			
			System.out.println(Thread.currentThread().getName()+ "terminated.");
		}
	}
}

这个join调用的是

从而调用了join（0），即mills=0

且获取了这个线程的锁。


当前线程A调用B的join方法，因为在join里面有个wait（0），从而使得线程A在线程B的对象上阻塞，然后当线程B结束时，才会待用notifyAll，通知自身的等待队列上的线程。

数据库连接池案例