java中线程间数据共享和线程间通信

一：如果没个线程执行的代码相同，就可以使用同一个runnable对象
这个runnable对象中有那个共享数据，例如，卖票系统
二：如果每个线程执行的代码不同，这时候需要用不同的runnable
对象，有如下几种方式来实现这些runnable对象之间的数据共享
1把共享数据封装在另外一个对象中，然后将这个对象逐一传递

给各个runnable对象，每个线程对共享数据的操作方法也分配
到那个对象本身上，这样容易实现针对该数据进行的各个操作
的互斥和通信
2把这些runnable对象作为某一类中的内部类，共享数据作为这个
外部类中的成员变量，每个线程对共享数据的操作方法也分配给
外部类，以便实现对共享数据进行的各个操作的互斥和通信，作为内部类的各个runnable对象调用外部类的这些方法

3以上两种方式的接合，将共享数据封装在另外一个对象中，每个线程
对共享数据的操作方法也分配到那个对象身上，对象作为这个外部类中的成员变量
或方法中的局部变量，每个线程的runnable对象作为外部类中的成员内部类或局部内部类
总之，要同步互斥的几段代码最好分别放在独立的方法中，这些方法再
放在同一个类中，这样比较容易实现它们之间的互斥和通信

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 2把这些runnable对象作为某一类中的内部类，共享数据作为这个 外部类中的成员变量，每个线程对共享数据的操作方法也分配给
 * 外部类，以便实现对共享数据进行的各个操作的互斥和通信，作为内部类 的各个runnable对象调用外部类的这些方法 jdk1.5+中的线程通信
 * 
 * @author liyutao
 *
 */
public class Test5 {

	// private static ShareData1 data1 = new ShareData1();//共享数据

	public static void main(String[] args) {

		final ShareD data1 = new ShareD();// 共享数据

		// 为了实现效果 让两个匿名内部类线程之间可以进行通信

		Lock lock = new ReentrantLock();
		Condition condition = lock.newCondition();
		boolean bShouldSub = true;

		// {
		lock.lock();
		try {
			while (!bShouldSub) {
				try {
					condition.await();
				} catch (Exception e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			// runnable对象作为某一类中的内部类
			new Thread(new Runnable() {
				@Override
				public void run() {
					data1.increment();

				}
			}).start();

			bShouldSub = true;
			condition.signal();
		} finally {
			lock.unlock();
		}
		// }

		// {
		lock.lock();
		try {
			while (!bShouldSub) {
				try {
					condition.await();
				} catch (Exception e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			// runnable对象作为某一类中的内部类
			new Thread(new Runnable() {
				@Override
				public void run() {
					data1.decrement();

				}
			}).start();
			bShouldSub = false;
			condition.signal();
		} finally {
			lock.unlock();
		}

	}

	// }
}

class ShareD {
	private int j = 0;

	public void increment() {
		while (j < 10) {
			j++;
			System.out.println("increment=" + j);
		}
	}

	public void decrement() {
		while (j > 0) {
			j--;
			System.out.println("decrement=" + j);
		}
	}
}

/**
 * 1把共享数据封装在另外一个对象中，然后将这个对象逐一传递
给各个runnable对象，每个线程对共享数据的操作方法也分配
到那个对象本身上，这样容易实现针对该数据进行的各个操作
的互斥和通信
 *代码中用到了传统的线程间通信 
 * @author liyutao
 */
public class Test {
	 public static void main(String[] args) {
			ShareData1 data2 = new ShareData1();
			new Thread(new MyRunnable1(data2)).start();
			new Thread(new MyRunnable2(data2)).start();
	}
}	

class MyRunnable1 implements Runnable{
	private ShareData1 data1;
	public MyRunnable1(ShareData1 data1){
		this.data1 = data1;
	}
	public void run() {
		data1.decrement();
		
	}
}

class MyRunnable2 implements Runnable{
	private ShareData1 data1;
	public MyRunnable2(ShareData1 data1){
		this.data1 = data1;
	}
	public void run() {
		data1.increment();
	}
}

class ShareData1 /*implements Runnable*/{
/*		private int count = 100;
	@Override
	public void run() {
		// TODO Auto-generated method stub
		while(true){
			count--;
		}
	}*/
	
		private int j = 0;
	  private boolean bShouldSub = true;
	public synchronized void increment(){
		  while(!bShouldSub){
			  try {
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		  }
		for(int i=0;i<5;i++){
			
			j++;
			System.out.println(j);
		}
		 bShouldSub = false;
		  this.notify();
		  System.out.println("==================");
	}
	
	public synchronized void decrement(){
		 while(bShouldSub){
			  try {
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		  }
		for(int i=0;i<5;i++){
			System.out.println(j);
			j--;
			
		}
		bShouldSub = true;
		this.notify();
	}
}

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 1把共享数据封装在另外一个对象中，然后将这个对象逐一传递
给各个runnable对象，每个线程对共享数据的操作方法也分配
到那个对象本身上，这样容易实现针对该数据进行的各个操作
的互斥和通信
jdk1.5+中的线程间通信
 * @author liyutao
 */
public class Test3 {
	 public static void main(String[] args) {
			ShareData2 data2 = new ShareData2();
			new Thread(new MyRunnable4(data2)).start();
			new Thread(new MyRunnable3(data2)).start();
	}
}	
class MyRunnable3 implements Runnable{
	private ShareData2 data2;
	public MyRunnable3(ShareData2 data2){
		this.data2 = data2;
	}
	public void run() {
		data2.decrement();
	}
}

class MyRunnable4 implements Runnable{
	private ShareData2 data2;
	public MyRunnable4(ShareData2 data2){
		this.data2 = data2;
	}
	public void run() {
		data2.increment();
	}
}

class ShareData2 {
		private int j = 0;
		Lock lock = new ReentrantLock();
		Condition condition = lock.newCondition();
	  private boolean bShouldSub = true;
	  public  void increment(){
		 lock.lock();
			 try {
				  while(!bShouldSub){
					  try {
						  condition.await();
					} catch (Exception e) {
						e.printStackTrace();
					}
				  }
					for(int i=0;i<5;i++){
						
						j++;
						System.out.println(j);
					}
					  bShouldSub = false;
					  condition.signal();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}finally {
				 lock.unlock();
			}
		  System.out.println("==================");
	}
	
	public  void decrement(){
		lock.lock();
		 try {
			  while(bShouldSub){
				  try {
					  condition.await();
				} catch (Exception e) {
					e.printStackTrace();
				}
			  }
				for(int i=0;i<5;i++){
					System.out.println(j);
					j--;
					
				}
				  bShouldSub = true;
				  condition.signal();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			 lock.unlock();
		}
	}
}

public class TestSix {
   private int j;
	public static void main(String[] args) {
		TestSix tt=new TestSix();
		Inc inc=tt.new Inc();
		Dec dec=tt.new Dec();
		
		for(int i=0;i<2;i++){
			Thread t=new Thread(inc);
			t.start();
			t=new Thread(dec);
			t.start();
		}
	}

	class Dec implements Runnable{
		@Override
		public void run() {
			// TODO Auto-generated method stub
			for(int i=0;i<5;i++){
				dec();
			}
		}
	}
	class Inc implements Runnable{
		@Override
		public void run() {
			// TODO Auto-generated method stub
			for(int i=0;i<5;i++){
				inc();
			}
		}
	}
	
	private synchronized void dec(){
		j--;
		System.out.println(Thread.currentThread().getName()+"-dec="+j);
		
	}
	private synchronized void inc(){
		j++;
		System.out.println(Thread.currentThread().getName()+"-inc="+j);
		
	}
}