《J2SE 回炉再造16》-------溺水狗

第十章 线程

1. 提纲

2. 线程的基本概念
进程是一个静态的概念，严格意义上讲并不能执行，我们所说的进程执行指的是进程里的主线程（main()方法）开始执行了

3. 线程的创建和启动
只要可以使用接口就不要使用继承，接口更加灵活。

实现Runnable接口创建线程简例：

效果图：

继承Thread类创建线程简例：

效果图：

4. 线程的状态转换

5. 线程控制的基本方法

• sleep()方法简例：

import java.util.Date;
public class TestInterrupt {
	public static void main(String[] args) {
		MyThread thread = new MyThread();
		thread.start();
		try {
			Thread.sleep(10000);       // 1秒(s)=1000毫秒(ms)
		} catch (InterruptedException e) {}
		thread.interrupt(); //中断线程
	}
}

class MyThread extends Thread {
	public void run() {
		while(true) {
			System.out.println("==="+new Date()+"===");
			try {
				sleep(1000);  
			} catch(InterruptedException e) {
				return;
			}
		}
	}
}

效果图：

分析：


interrupt()虽然不好但是仍然可以捕获异常，此时可以关闭已经打开的资源文件；但如果使用stop（）方法将直接杀死线程，目前已经被废弃，不建议使用。最佳关闭方式是设置一个标志量flag，当flag为true时调用线程，flag为false时结束线程。下文有改进的代码。

• join（）方法简例：

public class TestJoin {
	public static void main(String[] args) {
		MyThread2 t1 = new MyThread2("t1");
		t1.start();
		try {
			t1.join();
		} catch (InterruptedException e) {}
		for(int i=0;i<=10;i++) {
			System.out.println("I am main thread");
		}
	}
}

class MyThread2 extends Thread {
	MyThread2 (String s) {
		super(s);   //给线程起名字。
	}
	public void run() {
		for(int i=0;i<=10;i++) {
			System.out.println("i am "+getName());
			try {
				sleep(1000);
			} catch (InterruptedException e) {
				return;
			}
		}
	}
}

效果图：

join相当于方法调用，就是先执行线程t1,再继续执行主线程。

• yield()方法简例：

public class TestYield {
	public static void main(String[] args) {
		MyThread3 t1 = new MyThread3("t1");
		MyThread3 t2 = new MyThread3("t2");
		t1.start();
		t2.start();
	}
}

class MyThread3 extends Thread {
	MyThread3(String s) {
		super(s);
	}
	public void run() {
		for (int i=0;i<=100;i++) {
			System.out.println(getName() + ":" + i);
			if(i%10==0) {
				yield();
			}
		}
	}
}

效果图：

yield（）方法，会向调度程序提示当前线程愿意放弃当前对处理器的使用，但调度程序可以忽略此提示，并继续这一线程的执行。

6. 线程的优先级别

简例代码：

public class TestPriority {
	public static void main(String[] args) {
		Thread t1 = new Thread(new T1());
		Thread t2 = new Thread(new T2());
		t1.setPriority(Thread.NORM_PRIORITY + 4);
		t1.start();
		t2.start();
	}
}

class T1 implements Runnable {
	public void run() {
		for(int i=0;i<1000;i++) {
			System.out.println("T1:" + i);
		}
	}
}

class T2 implements Runnable {
	public void run() {
		for(int i=0;i<1000;i++) {
			System.out.println("++++T2:" + i);
		}
	}
}

人为调高线程t1的优先级，使线程t1可以占用更多的时间片，优先完成。

线程小例子1：

线程小例子2：

线程小例子3：

线程小例子4：

线程小例子5：

7. 线程同步

首先使用一个小例子说明线程同步的重要性：

先要的效果是：一个是第一线程，一个是第二线程；但代码运行时产生的显示都为第二线程，这是因为第一个线程执行到num++(此时num=1)时睡眠，并未执行到输出语句，就开始了第二个线程的执行，又一次num++(num=2），并输出。此时第一个线程苏醒并输出，就造成了上图的效果。下面使用synchronized关键字锁定当前对象（线程）进行修改。


模拟死锁—（著名的哲学家吃饭问题）

解决方法（粗略）：
解决线程死锁最好只锁定一个对象，别锁定俩。把锁的粒度加粗（解决方法其一），直接锁定当前的整个对象就好了，不要锁定其中两个小对象。

• 一道经典的面试题：请问此时输出什么？
  
  输出的结果：
  
  分析(这个结果说明了什么?)：
  程序执行的过程是：先执行线程t,此时b=1000,然后线程睡眠。同时主线程睡眠后苏醒调用m2()方法,输出1000，然后线程t苏醒，输出b=1000，这说明synchronization锁定的是当前对象，即别的线程无法访问被锁定函数的下文，但别的线程可以访问没有被锁定的方法。如果不可以访问的话，此时第一次输出的值应该为100。

• 延伸题(此时输出是什么？)：
  
  结果：
  
  分析：这个是对上面面试题所分析的结果进行论证，可以想象为银行账户，当我们决定对同一个对象设置不同的方法时，当我们设置了其中一个为同步方法，就要考虑别的方法是否要设置同步，不设置同步是否会对资源造成不良访问。

• 延伸题：此时的输出是什么？
  
  答案：
  
  分析：一个方法做了同步，另一个方法没有做同步，别的线程可以自由访问未做同步的那个方法，并且可能会对做了同步的方法产生影响；也就是说要保护好某一个类里的某一个对象时（要保护好要同步的对象时）必须对访问这个对象的所有方法仔细地考虑加不加同步，加了同步很有可能效率会变低，不加同步有可能产生数据不一致的现象。

• 生产者消费者问题
  代码：

public class ProducerConsumer {
	public static void main (String[] args) {
		SyncStack ss = new SyncStack();
		Producer p = new Producer(ss);
		Consumer c = new Consumer(ss);
		new Thread(p).start();
		new Thread(c).start();
	}
}
//窝头类
class WoTou {
	int id;   //每个窝头有一个id
	WoTou(int id) {
		this.id = id;
	}
	
	public String toString() {  
		return "WoTou:" + id;
	}
}
//容器类———>先进后出（栈）
class SyncStack {
	int index = 0;  //栈指针
	WoTou[] arrWT = new WoTou[6];   //假设篮子只能存放6个
	
	public synchronized void push(WoTou wt) {    //放窝头
		while(index == arrWT.length) {    
			try {
				this.wait();   //当篮子装满6个要使生产者线程进行等待
			} catch(InterruptedException e) {
				e.printStackTrace();
			}
		}
		this.notify();    //叫醒消费者线程，进行消费
		arrWT[index]  = wt;  //index位置放入窝头
		index ++;  //栈顶指针加一
	}
	
	public synchronized WoTou pop() {    //取窝头
		while(index == 0) {
			try {
				this.wait();   //当篮子里没有窝头时消费者线程进行等待
			} catch(InterruptedException e) {
				e.printStackTrace();
			}
		}
		this.notify() ;  //叫醒生产者线程开始生产
		index --; //栈顶指针下移
		return arrWT[index];  //得到窝头
	}
}

class Producer implements Runnable {   //生产者类
	SyncStack ss = null;
	Producer(SyncStack ss){       //每一个生产者都要指向一个篮子
		this.ss = ss;
	}
	
	public void run() {
		for(int i=0;i<20;i++) {      //每个生产者最多生产20个
			WoTou wt = new WoTou(i);
			ss.push(wt);       //每生产一个就放入篮子
			System.out.println("+++Producer :" + wt);
			try {
				Thread.sleep((int)(Math.random() * 200));
			} catch(InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

class Consumer implements Runnable {  //消费者
	SyncStack ss = null;
	Consumer(SyncStack ss){     //每一个消费者也要对应一个篮子进行消费
		this.ss = ss;
	}
	
	public void run() {
		for(int i=0;i<20;i++) {     //一个消费者要消费20个窝头
			WoTou wt = ss.pop();     //将篮子里的窝头从篮子里拿出来
			System.out.println("***Consumer:" + wt);
			try {
				Thread.sleep((int)(Math.random() * 1000));
			} catch(InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

分析：

• wait()方法：这个方法并不是来自Thread类，而是来自Object类，这个方法只适用于synchronization修饰的方法，没有锁定就谈不上等待。使用的意义是，每个篮子只能装6个，假设消费速度远不及生产速度，当篮子中装满6个还在向里装，就会导致数组越界问题，所以要检测当篮子已经装满时就要让生产者开始等待。即当前正在这个对象访问的线程（拿到对象锁的线程）等待。与sleep()不同的是，当线程wait()时，别的线程可以访问被锁定对象，而sleep()时别的线程不可以访问被锁定的对象。
• notify()方法：和wait()方法成对使用，叫醒当前对象上等待的线程。使用意义：当篮子装满时，生产者线程开始等待，然后消费者线程运行，当篮子为空时要让消费者线程等待，同时唤醒生产者线程开始生产。
• notifyAll()方法：作用同nitify()，但此时是唤醒当前对象上等待的多个线程。
• 为什么使用while循环而不是if，如果使用if，当篮子装满6个，这时候假设被打断捕获InterruptedException，然后跳出if而没有使生产者线程等待，继续向下依次执行，this.notify(); arrWT[index] = wt; index ++; 这个时候就会溢出。而要是while的话，即使捕获异常这时候仍然会检验条件（篮子有多少个）才会继续向下进行。
  

8. 总结

注：本博客由溺水狗原创但其学习资源资料来源于网络（马士兵老师的教学视频），特此感谢马士兵老师