Java多线程（2）

线程的生命周期

JDK中用Thread.State类定义了线程的几种状态

• 新建： 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
• 就绪： 处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源
• 运行： 当就绪的线程被调度并获得CPU资源时，便进入运行状态
• 阻塞： 在某种特殊情况下，被人为挂起或执行输入输出操作时，让出CPU并临时中止自己的执行，进入阻塞状态
• 死亡： 线程完成了它的全部工作或线程被提前强制性的终止或出现异常导致结束
  

线程的同步(通过同步机制解决线程的安全问题)

方式一：同步代码块

synchronized(同步监视器){
	//需要被同步的代码
}

说明：

1. 操作共享数据的代码，即为需要被同步的代码
2. 共享数据：多个线程共同操作的变量
3. 同步监视器，俗称‘锁’。任何一个类的对象，都可以充当锁。但是要求多个线程必须共用同一把锁。

方式二：同步方法
将操作共享数据的代码完整的声明在一个方法中，此方法通过synchronized修饰。
说明：

1. 同步方法任然涉及到同步监视器，只是不需要我们显示的声明。
2. 非静态的同步方法，同步监视器是this。静态的同步方法，同步监视器是当前类本身。

方式三：Lock锁

1. 实例化ReentrantLock
2. 调用锁定方法lock()
3. 调用解锁方法unlock()

class Window implements Runnable{

    private int ticket = 100;
    private ReentrantLock lock = new ReentrantLock();// 1. 实例化ReentrantLock

    @Override
    public void run() {
        while(true){
            try{
                lock.lock();//2. 调用锁定方法lock()
                if (ticket > 0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":" + ticket);
                    ticket--;
                } else {
                    break;
                }
            } finally {
                lock.unlock();//3. 调用解锁方法unlock()
            }

        }
    }
}

synchronized与Lock锁的异同

• 相同：二者都可以解决线程安全问题
• 不同：synchronized机制在执行完相应的同步代码后，自动的释放同步监视器。Lock需要手动的启动同步（lock()），同时也需要手动的结束同步（unlock()）。

单例模式之懒汉式的线程安全
例如：

class Bank{
	private Bank(){}
	private static Bank instance = null;
	public static Bank getInstance(){
		//方式一：效率稍差
		//synchronized (Bank.class){
		//	if(instance == null){
		//		instance = new Bank();
		//	}
		//	return instance;
		//}
		
		//方式二：效率更高
		if(instance == null){
			synchronized (Bank.class){
				if(instance == null){
					instance = new Bank();
				}
			}
		}
		return instance;
	}
}

线程的死锁

死锁

• 不同的线程分别占用对方的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
• 促会先死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续

解决方法

• 专门的算法，原则
• 尽量减少同步资源的定义
• 尽量避免嵌套同步

线程通信

涉及到的三个方法：

• wait()：一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
• notify()：一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个。
• notifiAll()：一旦执行此方法，就会唤醒所有被wait的线程。

说明：

1. wait()，notify()，notifiAll()三个方法必须使用在同步代码块或同步方法中。
2. 此三个方法的调用者必须是同步代码块或同步方法中的同步监视器。否则，会出现异常。
3. 此三个方法是定义在Object类中。

sleep()和wait()的异同
相同点：一旦执行方法，都可以使得当前线程进入阻塞状态。
不同点：

1. 两个方法声明的位置不同：Thread类中声明sleep()，Object类中声明wait()。
2. 调用的要求不同：sleep()可以在任何需要的场景调用，wait()必须在同步代码块或同步方法中调用。
3. 关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放同步监视器，wait()会释放同步监视器。

JDK5.0 新增的线程创建方式

新增方式一：实现Callable接口

1. 创建一个实现Callable接口的实现类
2. 实现call方法，将此线程需要执行的操作声明在call()中
3. 创建Callable实现类的对象
4. 将此Callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象
5. 将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并start()
6. 使用FutureTask的对象的get() 方法获取Callable中call方法的返回值（get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值）

实现Callable接口方式创建多线程相较于实现Runnable接口创建多线程的强大之处

1. call() 可以有返回值，而run() 没有返回值
2. call() 可以抛出异常，被外面的操作捕获，获取异常的信息
3. Callable是支持泛型的

新增方式二：使用线程池
提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中，可以避免频繁创建销毁线程，实现重复利用。
提高了响应速度（减少了创建线程的时间）
降低资源消耗（重复利用线程池中线程，不需要每次都创建）
便于线程管理

1. 提供指定线程数量的线程池ExecutorService service = Executors.newFixedThreadPool(10);
2. 执行指定的线程的操作，需要提供实现Runnable接口或Callable接口实现类的对象
   service.execute(new NumberThread());//适合使用Runnable
   service.submit();//适合使用Callable
3. 关闭线程池service.shutdown();