Java线程(7)

Java总结篇系列：Java多线程（一）

（http://www.cnblogs.com/lwbqqyumidi/p/3804883.html）

一.线程的生命周期及五种基本状态

二. Java多线程的创建及启动

1、实现Runnable接口，并重写该接口的run()方法，该run()方法同样是线程执行体，创建Runnable实现类的实例，并以此实例作为Thread类的target来创建Thread对象，该Thread对象才是真正的线程对象。（推荐使用）

2、继承Thread类，重写该类的run()方法。

3、使用Callable和Future接口创建线程。具体是创建Callable接口的实现类，并实现clall()方法。并使用FutureTask类来包装Callable实现类的对象，且以此FutureTask对象作为Thread对象的target来创建线程。

三. Java多线程的就绪、运行和死亡状态

就绪状态转换为运行状态：当此线程得到处理器资源；

运行状态转换为就绪状态：当此线程主动调用yield()方法或在运行过程中失去处理器资源。

运行状态转换为死亡状态：当此线程线程执行体执行完毕或发生了异常。

此处需要特别注意的是：当调用线程的yield()方法时，线程从运行状态转换为就绪状态，但接下来CPU调度就绪状态中的哪个线程具有一定的随机性，因此，可能会出现A线程调用了yield()方法后，接下来CPU仍然调度了A线程的情况。

由于实际的业务需要，常常会遇到需要在特定时机终止某一线程的运行，使其进入到死亡状态。目前最通用的做法是设置一boolean型的变量，当条件满足时，使线程执行体快速执行完毕。

（http://blog.csdn.net/jinhongliang123/article/details/7934678）

Wait sleep区别
1   wait时别的线程可以访问锁定对象
------------------调用wait方法的时候必须锁定对象
2   sleep时别的线程也不可以访问锁定对象


第九章总结
1   线程/进程的概念
2   创建和启动线程的方式
3   sleep
4   join
5   yield
6   synchronized
7   wait
8   notify/notifyAll

示例代码：（马士兵--线程）

/*范例名称：
 * 原文件名称：
 * 要点：
 * 1. 线程
  
 */
import java.util.*;//包含Date()

public class ThreadTest {
	public static void main(String[] args) {
		///
		//线程类_方法1
		///
		Runner1 r=new Runner1();//方法1
		Thread t=new Thread(r);
		t.start();//启动线程
		
		///
		//线程类_方法2
		///
		Runner2 r2=new Runner2();//方法2
		r2.start();//启动线程
		
		for(int i=0;i<15;i++){
			System.out.println("Main Thread: "+i);
		}
		
		///
		//线程类_sleep方法
		///
		MyThread thread1=new MyThread("Hello thread");
		thread1.start();
		try{
			Thread.sleep(5000);//主线程 休眠5s
		}catch (InterruptedException e) {
			return;
		}
		//thread1.interrupt();//打断线程
		thread1.shutDown();
		
		///
		//线程同步
		///
		TestSync test=new TestSync();
		Thread t1=new Thread(test);
		Thread t2=new Thread(test);
		t1.setName("T1");
		t2.setName("T2");
		t1.start();t2.start();

	}
}

//线程类对象_方法1 (使用Runnable接口比从Thread类继承更灵活)
class Runner1 implements Runnable{
	//重写run方法
	public void run() {
		for(int i=0;i<15;i++){
			System.out.println("Runner1: "+i);
		}
	}
}

//线程类对象_方法2
class Runner2 extends Thread{
	//重写run方法
	public void run() {
		for(int i=0;i<15;i++){
			System.out.println("Runner2: "+i);
		}
	}
}

//线程类对象_方法2
class MyThread extends Thread{
	private boolean flag=true;//通过变量结束线程比较方便
	
	public MyThread(String threadName) {
		super(threadName);//起名字
	}
	public void run(){
		while(flag){
			System.out.println("I am "+getName());
			System.out.println("==="+new Date()+"===");
			try{
				sleep(1000);
			}catch (InterruptedException e) {
				return;
			}
		}
	}
	public void shutDown(){
		flag=false;
	}
}

///
//线程同步
class TestSync implements Runnable{
	Timer timer=new Timer();
	public void run(){
		timer.add(Thread.currentThread().getName());
	}
}
class Timer{
	private static int num=0;
	
	public synchronized void add(String name){//锁定当前对象；互斥
	//public void add(String name){//没有锁定
		num++;
		try{Thread.sleep(100);}
		catch(InterruptedException e){}
		System.out.println(name+", 第"+num+"个使用timer的线程");
	}
}

运行结果：

Runner1: 0
Runner1: 1
Runner1: 2
Runner1: 3
Runner1: 4
Runner1: 5
Runner1: 6
Runner1: 7
Runner1: 8
Runner1: 9
Runner1: 10
Runner1: 11
Runner1: 12
Runner1: 13
Runner1: 14
Main Thread: 0
Main Thread: 1
Main Thread: 2
Main Thread: 3
Main Thread: 4
Main Thread: 5
Main Thread: 6
Main Thread: 7
Main Thread: 8
Main Thread: 9
Main Thread: 10
Main Thread: 11
Main Thread: 12
Main Thread: 13
Main Thread: 14
Runner2: 0
Runner2: 1
Runner2: 2
Runner2: 3
Runner2: 4
Runner2: 5
Runner2: 6
Runner2: 7
Runner2: 8
Runner2: 9
Runner2: 10
Runner2: 11
Runner2: 12
Runner2: 13
Runner2: 14
I am Hello thread
===Sun Dec 18 17:01:35 CST 2016===
I am Hello thread
===Sun Dec 18 17:01:36 CST 2016===
I am Hello thread
===Sun Dec 18 17:01:37 CST 2016===
I am Hello thread
===Sun Dec 18 17:01:38 CST 2016===
I am Hello thread
===Sun Dec 18 17:01:39 CST 2016===
T1, 第1个使用timer的线程
T2, 第2个使用timer的线程