多线程总结下篇（基础知识）

多线程总结下篇

 

1、线程间的通讯通信---等待唤醒机制 

上一篇博客简单说了一下线程的切换，线程的切换在开发中是比较常见的，为了线程中的通信，可以采取等待唤醒机制，那什么是等待唤醒机制呢？

看下面的这个例子：有一个资源Res，这个Res类中有存资源和取资源的方法，要存100个资源，再取100个资源，为了保证资源的唯一，采取用单例设计模式。
现在开启两个线程对资源Res进行操作，一个线程（Input）往里面存，一个线程（Output）往外面取，往里面存了一条，就往外面取一条，那么问题来了，线程（Input）存了资 源之后怎么先停下来，通知线程（Output）往外面取呢？这就用到了等待唤醒机制！

具体代码如下：

/**
 * 资源类，有取资源和存资源的方法
 * @author wangjing
 *
 */
class Res {
	private String name;// 定义了一个名字，用于把传递进来的名字赋值给name变量
	private String hobby;// 定义了一个信息，用于把传递进来的内容赋值给user变量
	private boolean flag;// 为了线程的通讯，定义了一个标记，默认值是false
	private int count = 100;// 定义了一个共享数据，由于资源是唯一的，所以不用被static修饰

	/* 对函数进行同步，使每次传递进行的数据只能存放一个，当然如果不存放数据的话，那么将无法继续取走 */
	// 为了保证资源的唯一性，所以使用了单例设计模式
	private Res() {
	}

	private static Res res = null;// 懒汉式，对象的延迟加载.

	public static Res getInstanceof() {
		/* 加入多重判断提高效率 */
		if (res == null)
			synchronized (Res.class) {
				/* 再次判断，如果引用变量值为空，就在本类中创建本类对象 */
			        if (res == null)
				   res = new Res();
			}
		/* 返回这个类的本类对象 */
		return res;
	}

	public synchronized void input(String name, String hobby) {
		while (flag) {
			/* 判断标记是否为true，如果为true就wait，因为里面还有数据，无法继续存放 */
			try {
				wait();
			 } catch (Exception e) {
			}
		}
		if (count > 0) {
			this.name = name;
			this.hobby = hobby;
			// 为了线程的通讯，把标志改为真。
			flag = true;
			// 唤醒所有正在等待的线程
			notifyAll();
			System.out.println(Thread.currentThread().getName() + "："
					+ name + "：" + hobby + "："  +count
					);
		} else {
			System.out.println("数据库已经满了");
			System.exit(0);

		}

	}

	/*
	 * 对函数进行同步，跟input函数进行互斥，使每次取出数据的时候只能取走input存放的数据（当然数据只有一个）
	 * 当然如果数据不取空的话，那么将无法继续存放
	 */
	public synchronized void output() {

		while (!flag) {
			/* 判断标记是否为true，如果为true就wait，因为里面没有数据，无法继续取出 */
			try {
				wait();
			} catch (Exception e) {
			}

		}

		System.out.println(Thread.currentThread().getName() + ":"	+ name + "：" + hobby +"\t" + "还剩数据"+--count+"条");
		// 为了线程的互斥，把标志改为假。
		flag = false;
		notify();
	}
}

程序的执行结果如下图：

看完了代码思考这样两个个问题。
    问题一：wait(), notify() ,notifyAll(),用来操作线程的方法为什么定义在了Object类中？ 
因为这些方法在操作同步中，线程同步，都必须要表示它们所操作线程持有的锁，只有同一个锁上的被等待线程，可以被同一个锁notify唤醒，不可以对不同锁中的线程进行等待唤醒。 
也就是说，等待和唤醒必须是同一个锁。所以要使用在同步中，因为只有同步才具有锁。 
  
    问题二：wait()   sleep() 有什么区别？ 
 wait()   ：释放资源，释放锁 。 
 sleep()   ：释放资源，不释放锁。 

二、生产者消费者问题

如果上面的例子没有看懂，看下面这个类似的！

情景描述：生产者生产商品，消费者消费商品。现在有一个蛋糕房，可以生产蛋糕！

class CakeHouse {
	// 蛋糕房 蛋糕窗口
	private List<Object> list = new LinkedList<Object>();
	private int index;

	// 必须先同步，才能使用锁监视器
	public synchronized void put() {
		while (!list.isEmpty()) {
			// 已经有蛋糕
			try {
				this.wait(); // 调用wait的对象 就是锁定对象
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		// 生产蛋糕
		list.add(new Object());
		index++;
		System.out.println("生产者 生产蛋糕 " + index);

		// 通知消费者 快去吃
		this.notify();
	}

	public synchronized void take() {
		while (list.isEmpty()) {
			// 没蛋糕
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

		// 吃掉蛋糕
		list.remove(0);
		System.out.println("消费者消费蛋糕 " + index);

		// 通知生产者生产
		this.notify();
	}
}

<span style="font-size:14px;">// 消费者
class Consumer implements Runnable {
	private CakeHouse cakeHouse;

	public Consumer(CakeHouse cakeHouse) {
		this.cakeHouse = cakeHouse;
	}

	@Override
	public void run() {
		for (int i = 0; i < 100; i++) {
			cakeHouse.take();
		}
	}

}

// 生产者
class Producer implements Runnable {

	private CakeHouse cakeHouse;

	public Producer(CakeHouse cakeHouse) {
		this.cakeHouse = cakeHouse;
	}

	@Override
	public void run() {
		// 生产100个蛋糕
		for (int i = 0; i < 10; i++) {
			cakeHouse.put();
		}
	}

}</span>

/**
 * 生产者 消费者案例
 * 
 * @author wangjing
 * 
 */
public class ProducerConsumerTest {
	public static void main(String[] args) {
		CakeHouse cakeHouse = new CakeHouse();
		new Thread(new Producer(cakeHouse)).start();
		new Thread(new Consumer(cakeHouse)).start();
	}
}</span>

程序的执行结果：

生产者 生产蛋糕 1
消费者消费蛋糕 1
生产者 生产蛋糕 2
消费者消费蛋糕 2
生产者 生产蛋糕 3
消费者消费蛋糕 3

.

.

.

生产者 生产蛋糕 99
消费者消费蛋糕 99
生产者 生产蛋糕 100
消费者消费蛋糕 100

三、Lock&Condition实现线程同步通信

JDK1.5中，提供了许多线程解决方案，将同步synchrozed 替换成 显示 Lock 操作 
 将Object 中的 wait ,notify,notifyAll,替换成了condition 对象。 
   
          Lock是java.util.concurrent.locks包下的接口，Lock 实现提供了比使用synchronized 方法和语句可获得的更广泛的锁定操作，它能以更优雅的方式处理线程同步问题。
 在Condition中，用await()替换wait()，用signal()替换notify()，用signalAll()替换notifyAll()，传统线程的通信方式，Condition都可以实现，这里注意，Condition是被绑定到Lock上的，要创建一个Lock的Condition必须用newCondition()方法。
 这样看来，Condition和传统的线程通信没什么区别，Condition的强大之处在于它可以为多个线程间建立不同的Condition，下面引入API中的一段代码，加以说明。

class CakeHouse {
	// 蛋糕房 蛋糕窗口
	private List<Object> list = new LinkedList<Object>();
	private int index;
	private Lock lock = new ReentrantLock();
	// 生产者专用监视器
	private Condition producerCondition = lock.newCondition();
	// 消费者专用监视器
	private Condition consumerCondition = lock.newCondition();

	public void put() {
		lock.lock();
		while (!list.isEmpty()) {
			// 已经有蛋糕
			try {
				producerCondition.await(); // 在生产者监视器上等
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		// 生产蛋糕
		list.add(new Object());
		index++;
		System.out.println("生产者 生产蛋糕 " + index);

		// 通知消费者 快去吃
		consumerCondition.signal();

		lock.unlock();
	}

	public void take() {
		lock.lock();
		while (list.isEmpty()) {
			// 没蛋糕
			try {
				consumerCondition.await();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

		// 吃掉蛋糕
		list.remove(0);
		System.out.println("消费者消费蛋糕 " + index);

		// 通知生产者生产
		producerCondition.signal();

		lock.unlock();
	}
}

    Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。此实现允许更灵活的结构，可以具有差别很大的属性，可以支持多个相关的Condition 对象。虽然synchronized 方法和语句的范围机制使得使用监视器锁编程方便了很多，而且还帮助避免了很多涉及到锁的常见编程错误，但有时也需要以更为灵活的方式使用锁。例如，某些遍历并发访问的数据结果的算法要求使用 "hand-over-hand" 或 "chain locking"：获取节点 A 的锁，然后再获取节点 B 的锁，然后释放 A 并获取 C，然后释放 B 并获取 D，依此类推。Lock 接口的实现允许锁在不同的作用范围内获取和释放，并允许以任何顺序获取和释放多个锁，从而支持使用这种技术。

四、线程终止

stop() 方法已经过时，如何停止线程？

只有一种，run()方法结束。开启多线程运行，运行代码通常是循环结构，只要控制住循环，就可以让run()方法结束，也就是线程结束。

特殊情况：当线程处于冻结状态（不是运行状态），就不会读取到标记，线程就不会结束。

当没有指定的方式让冻结的线程恢复到运行状态时，需要对冻结进行清除，强制让线程恢复到运行状态，这样就可以操作标记让线程结束，Thread类提供该方法interrupt();

class StopThread implements Runnable {
	private boolean flag = true; // 定义判断标记，让线程结束.
	public synchronized void run() {
		while (flag) {
			try {
				wait();
			}
			catch (InterruptedException e) {
				System.out.println(Thread.currentThread().getName()+ "……Exception");
				// flag =false; //当发生异常，说明调用了interrupt方法强制线程清楚冻结，希望线程停
				changFlag();
			}
			System.out.println(Thread.currentThread().getName() + "……run");

		}
	}
	public void changFlag() {
		flag = false;
	}
} 

public class StopDemo {
	public static void main(String[] args) {
		StopThread st = new StopThread();
		Thread t1 = new Thread(st);
		Thread t2 = new Thread(st);
	
		t1.start();
		t2.start();
		int num = 0;
		while (true) {
    		if (num++ == 60) {
				t1.interrupt();// 让冻结的线程恢复到运行状态
				t2.interrupt();
				break;
			}
			System.out.println(Thread.currentThread().getName() + "……" + num);
		}
		System.out.println("over");
	}
}

五、多线程(优先级&yield方法)

优先级：线程对象.setPriority(intnewPriority);设置线程优先权，1-10，默认5，越大，抢到CPU执行权机会越大；

（Thread.MAX_PRIORITY,  MIN_PRIORITY ,NORM_PRIORITY）

static void yield():暂停当前正在执行的线程，并执行其他线程，Thread.yield();