Java多线程（2）

                                                      —Input—>资源—Output—>

    线程间通信：其实就是多个线程在操作同一个资源，但是操作的动作不同。

    下面是一个关于线程间通信的例子：

/* 程序的部分运行结果：
    Jack   female
    Lily   male
    Jack   female
    Jack   female
    毫无疑问，出现了多线程安全问题。
    显然，我们可以通过同步的方式解决这个问题。
 */
class Resource {
	String name;
	String sex;
}

class Input implements Runnable {

	private Resource r;
	private int flag = 0;
	Input(Resource r) {
		this.r = r;
	}
	@Override
	public void run() {
		while (true){
			if (flag == 0) {
				r.name = "Jack";
				r.sex = "male";
			}else {
				r.name = "Lily";
				r.sex ="female";
			}
			flag = (flag+1)%2;
		}
		
	}
	
}

class Output implements Runnable {

	private Resource r;
	
	Output(Resource r) {
		this.r = r;
	}
	@Override
	public void run() {
		while (true)
		System.out.println(r.name + "   "  + r.sex);
	}
	
}

public class Multithread {
	/**
	 * @param args
	 */
	public static void main(String[] args) {

		Resource r = new Resource();
		
		Input in = new Input(r);
		Output out = new Output(r);
		
		Thread t1 = new Thread(in);
		Thread t2 = new Thread(out);
		
		t1.start();
		t2.start();
		
	}

}

     下面是解决方法：

/*
   部分运行结果：
Jack   male
Jack   male
Jack   male
Jack   male
Jack   male
Lily   female
Lily   female
Lily   female
Lily   female
Lily   female
Lily   female
*/

class Input implements Runnable {

	private Resource r;
	private int flag = 0;
	Input(Resource r) {
		this.r = r;
	}
	@Override
	public void run() {
		while (true){
                   synchronized(r) { // 这边的锁r，两个线程必须一样
			     if (flag == 0) {
				  r.name = "Jack";
				  r.sex = "male";
			      }else {
				  r.name = "Lily";
				  r.sex ="female";
			      }
			   flag = (flag+1)%2;
		       }
		  }
	}
	
}

class Output implements Runnable {

	private Resource r;
	
	Output(Resource r) {
		this.r = r;
	}
	@Override
	public void run() {
		while (true) {
		          synchronized(r) { // 和Input中的锁是同一个
                                System.out.println(r.name + "   "  + r.sex);
                          }
                } 
	}
	
}

    通过上面的结果分析，可得通过同步解决了安全问题，但是还是无法实现输入一次，打印一次，再输入一次，再打印一次。要实现这种情况，那么我们就要用到等待唤醒机制，看代码：

/*
  这种方法就是让两个线程交替的访问Resource对象。
*/

class Resource {
	String name;
	String sex;
	boolean accessable =  false; // 用来标识对象是否可以被操作
}

class Input implements Runnable {

	private Resource r;
	private int flag = 0;
	Input(Resource r) {
		this.r = r;
	}
	@Override
	public void run() {
		while (true){
			synchronized (r) {
				if (r.accessable) 
					try {
						r.wait(); // 我们是要wait持有r这个锁的线程，这个必须指明，因为同步可以嵌套同步
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				
				
				if (flag == 0) {
					r.name = "Jack";
					r.sex = "male";
				}else {
					r.name = "Lily";
					r.sex ="female";
				}
				
				flag = (flag+1)%2;
				r.accessable = true; // 为了唤醒Output对象
				r.notify();
				
					
			}
			
		}
		
	}
	
}

class Output implements Runnable {

	private Resource r;
	
	Output(Resource r) {
		this.r = r;
	}
	@Override
	public void run() {
		while (true)
			synchronized (r){
				if (!r.accessable)
					try {
						r.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}	
				System.out.println(r.name + "   "  + r.sex);
				r.accessable = false;  // 为了唤醒Input对象
				r.notify();
			}
		
	}
	
}

public class MuitThread {
	/**
	 * @param args
	 */
	public static void main(String[] args) {

		Resource r = new Resource();
		
		Input in = new Input(r);
		Output out = new Output(r);
		
		Thread t1 = new Thread(in);
		Thread t2 = new Thread(out);
		
		t1.start();
		t2.start();
		
	}

}

    wait(),notify(),notifyAll()，这三个方法都用在同步中，因为要对持有监视器（锁）的线程操作，而只有同步才具有锁。为什么这些操作线程的方法要定义在Object类中呢？因为这些方法在操作同步中的线程时，都必须标识它们所操作线程才有的锁（例如，r.wait(),r.notify()，这个r就是标识），等待和唤醒必须是同一把锁，而锁可以是任意对象，所以可以被任意对象调用的方法定义在Object中。

    下面将代码优化一下，并利用同步函数实现：

class Resource {
	private String name;
	private String sex;
	boolean accessable =  false; // 用来标识对象是否可以被操作
	
	public synchronized void set(String name, String sex){
		if (accessable) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		this.name = name;
		this.sex = sex;
		accessable = true;
		this.notify();
	}
	
	public synchronized void print() {
		if (!accessable) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println(name + " " + sex);
		accessable = false;
		this.notify();
	}
}

class Input implements Runnable {

	private Resource r;
	private int flag = 0;
	Input(Resource r) {
		this.r = r;
	}
	@Override
	public void run() {
		while (true){
				if (flag == 0) {
					r.set("Jack", "male");
				}else {
					r.set("Lily", "female");
				}				
				flag = (flag+1)%2;					
		}		
	}	
}

class Output implements Runnable {

	private Resource r;
	
	Output(Resource r) {
		this.r = r;
	}
	@Override
	public void run() {
		while (true)
			r.print();
	}	
}

public class MuitThread {
	public static void main(String[] args) {
		Resource r = new Resource();
		new Thread(new Input(r)).start();
		new Thread(new Output(r)).start();		
	}
}

    以上的例子都是一个生产者线程（Input）和一个消费者线程（Output），如果现在我们有多个生产者线程和多个消费者线程，那么会产生什么结果呢？让我们修改一下上面的代码：

    如何停止线程？只有一种，run()方法结束。开启多线程运行，运行代码通常是循环结构。只要控制住循环，就可以让run()方法结束，也就是线程结束。特殊情况：当线程处于了冻结状态，就不会读取到标记，那么线程就不会结束。当没有指定的方式让冻结的线程恢复到运行状态时，这时需要对冻结进行清除。强制让线程恢复到运行状态中来，这样就可以操作标记让线程结束。Thread类提供该方法 interrupt();它可以中断wait(),sleep(),join()方法。

    守护线程（Thread类有一个方法是setDaemon(boolean flag),需要在启动前调用）：即后台线程，当所有的前台线程都结束后，后台线程自动结束。

    join()方法：等该线程结束，该线程未结束前，CPU的执行权一直在该线程中。join()方法可以用来临时加入线程执行。

    Thread类的toString()方法：返回该线程的字符串表示形式，包括线程名称，优先级（默认优先级是5），线程组。

    yield()：暂停当前正在执行的线程，并执行其他线程。减缓线程的执行。