Java中的多线程

以下内容为本人观看尚硅谷Java学习视频所做的笔记

目录

• • 基本概念：程序、进程、线程
  • • 程序、进程、线程的概念
    • 单核CPU和多核CPU的理解
    • 并行与并发
    • 多线程的优点
  • 线程的创建和使用
  • • 多线程的创建，方式一：继承Thread类
    • Thread类的有关方法
    • 线程的调度
    • 线程的优先级
    • 多线程的创建，方式二：实现Runnable接口
    • 继承Thread法和实现Runnable接口法的比较
  • 线程的生命周期
  • 线程的同步
  • • 方式一：同步代码块
    • 方式二：同步方法
    • 使用同步的利弊
    • 线程安全的单例模式之懒汉式
    • 线程的死锁问题
    • Lock(锁)方式解决线程安全问题
  • 线程的通信
  • • 线程通信涉及到的三个方法：wait()、notify()、notifyAll()
    • sleep() 和 wait() 的异同
    • 经典例题：生产者 / 消费者问题
  • JDK5.0新增线程创建方式
  • • 新增方式一：实现Callable接口
    • 新增方式二：使用线程池

基本概念：程序、进程、线程

程序、进程、线程的概念

程序 (program) 是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。

进程 (process) 是程序的一次执行过程，或是正在进行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期

• 如：运行中的QQ，运行中的MP3播放器
• 程序是静态的，进程是动态的
• 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域

线程 (thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。

• 若一个进程同一时间并行执行多个线程，就是支持多线程的
• 线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小
• 一个进程中的多个线程共享相同的内存单元/内存地址空间 -> 它们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患

单核CPU和多核CPU的理解

• 单核CPU， 其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程的任务。例如:虽然有多车道，但是收费站只有一个工作人员在收费，只有收了费才能通过，那么CPU就好比收费人员。如果有某个人不想交钱，那么收费人员可以把他“挂起”(晾着他，等他想通了，准备好了钱，再去收费)。但是因为CPU时间单元特别短，因此感觉不出来。
• 如果是多核的话，才能更好的发挥多线程的效率。(现在的服务器都是多核的)
• 一个Java应用程序java.exe，其实至少有三个线程: main()主线程，gc()垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。

并行与并发

并行: 多个CPU同时执行多个任务。比如:多个人同时做不同的事。

并发: 一个CPU(采用时间片)同时执行多个任务。比如:秒杀、多个人做同一件事。

多线程的优点

背景：以单核CPU为例，只使用单个线程先后完成多个任务（调用多个方法），肯定比用多个线程来完成用的时间更短，为何仍需多线程呢?

多线程程序的优点:

1. 提高应用程序的响应。对图形化界面更有意义，可增强用户体验。
2. 提高计算机系统CPU的利用率
3. 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改

何时需要多线程

• 程序需要同时执行两个或多个任务。
• 程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。
• 需要一些后台运行的程序时。

线程的创建和使用

注意：以下程序不是多线程！

public class Sample{
	public void method1(String str){
		System.out.println(str);
	}

	public void method2(String str){
		method1(str);
	}

	private static void main() {
		Sample s = new Sample();
		s.method2("hello!");
	}
}

因为这并不是同时运行的，只要调用过程能用一条线勾出来，就不是多线程

多线程的创建，方式一：继承Thread类

• Java语言的JVM允许程序运行多个线程，它通过java.lang.Thread类来实现
• Thread类的特性
  • 每个线程都是通过某个特定Thread对象的 run() 方法来完成操作的，经常把 run() 方法的主体称为线程体
  • 通过该Thread对象的 start() 方法来启动这个线程，而非直接调用 run()

多线程的创建，方式一：继承于Thread类

1. 创建一个继承于Thread类的子类
2. 重写Thread类的run() --> 将此线程执行的操作声明在run()中
3. 创建Thread类的子类的对象
4. 通过该对象调动start()：①启动当前线程；②调用当前线程的run()

// 例子：遍历10以内的所有偶数
// 1. 创建一个继承于Thread类的子类
class MyThread extends Thread {
	// 2. 重写Thread类的run()
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			if (i % 2 == 0) {
				System.out.println(Thread.currentThread().getName() + ":" + i);
			}
		}
	}

	public static class Sample {
		public static void main(String[] args) {
			// 3. 创建Thread类的子类的对象
			MyThread t1 = new MyThread();

			// 4. 通过该对象调动start()
			t1.start();

			for (int i = 0; i < 10; i++) {
				if (i % 2 == 0) {
					System.out.println(Thread.currentThread().getName() + ":" + i);
				}
			}
		}
	}
}

输出

问题一：不能直接调用run()的方式启动线程

如果以上程序中不调用t1.start()而是直接调用t1.run()，代码如下：

// 例子：遍历10以内的所有偶数
class MyThread extends Thread {
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			if (i % 2 == 0) {
				System.out.println(Thread.currentThread().getName() + ":" + i);
			}
		}
	}

	public static class Sample {
		public static void main(String[] args) {
			MyThread t1 = new MyThread();

			// 注意这里调动run()而不是start()
			t1.run();

			for (int i = 0; i < 10; i++) {
				if (i % 2 == 0) {
					System.out.println(Thread.currentThread().getName() + ":" + i);
				}
			}
		}
	}
}

则输出如下

这说明，直接调用run()，并不会创建出新的线程，而是仍然在当前线程中执行run()中的代码。要创建新的线程，必须调用start()方法

问题二：不能让已经被调用start()的线程再去执行，不然会报IllegalThreadStateException的异常

// 例子：遍历10以内的所有偶数
class MyThread extends Thread {
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			if (i % 2 == 0) {
				System.out.println(Thread.currentThread().getName() + ":" + i);
			}
		}
	}

	public static class Sample {
		public static void main(String[] args) {
			MyThread t1 = new MyThread();

			// 注意这里调动两次start()
			t1.start();
			t1.start();

			for (int i = 0; i < 10; i++) {
				if (i % 2 == 0) {
					System.out.println(Thread.currentThread().getName() + ":" + i);
				}
			}
		}
	}
}

输出：

练习题：设计两个线程，一个遍历10以内奇数，一个遍历10以内偶数

写法一：

// 练习题：设计两个线程，一个遍历10以内奇数，一个遍历10以内偶数
public class Sample {
	public static void main(String[] args) {
		MyThread1 t1 = new MyThread1();
		MyThread2 t2 = new MyThread2();
		t1.start();
		t2.start();
	}
}

class MyThread1 extends Thread {
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			if (i % 2 == 1) {
				System.out.println(Thread.currentThread().getName() + ":" + i);
			}
		}
	}
}

class MyThread2 extends Thread {
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			if (i % 2 == 0) {
				System.out.println(Thread.currentThread().getName() + ":" + i);
			}
		}
	}
}

写法二（由于上面代码中类MyThread1和类MyThread2都是使用了一次就不用了，因此我们可以考虑使用匿名类法来写，这也是实际开发中很常用的写法）：

// 练习题：设计两个线程，一个遍历10以内奇数，一个遍历10以内偶数
public class Sample {
	public static void main(String[] args) {
		new Thread() {
			public void run() {
				for (int i = 0; i < 10; i++) {
					if (i % 2 == 1) {
						System.out.println(Thread.currentThread().getName() + ":" + i);
					}
				}
			}
		}.start();

		new Thread() {
			public void run() {
				for (int i = 0; i < 10; i++) {
					if (i % 2 == 0) {
						System.out.println(Thread.currentThread().getName() + ":" + i);
					}
				}
			}
		}.start();
	}
}

Thread类的有关方法

• void start(): 启动线程，并执行对象的run()方法
• run(): 线程在被调用时执行的操作
• String getName(): 返回线程的名称
• void setName(String name): 设置该线程名称
• static Thread currentThread(): 返回当前线程。在Thread子类中就是this，通常用于主线程和Runnable实现类
• static void yield(): 线程让步
  • 暂停当前正在执行的程序，把执行机会让给优先级相同或更高的线程
  • 若队列中没有同优先级的线程，忽略此方法
• join(): 当某个程序执行流中调用其他线程的join()方法时，调用线程将被阻塞，直到join()方法加入的join线程执行完为止（在线程a中调用线程b的join()方法，则此时线程a就进入阻塞状态，直到线程b执行完为止）
  • 低优先级的线程也可以获得执行
• static void sleep(long millis): （指定时间：毫秒）
  • 令当前活动线程在指定时间内放弃对CPU控制，即当前线程进入阻塞状态，使其他线程有机会被执行，时间到后重排队（所以并不是指定时间后立刻执行，只是不再阻塞，还要重新排队）
  • 抛出InterruptedException异常
• stop()（已过时的方法）: 强制线程生命周期结束，不推荐使用
• boolean isAlive(): 返回boolean，判断线程是否还活着

线程的调度

• 调度策略
  • 时间片轮转：每个进程被分配一时间段，称作它的时间片，即该进程允许运行的时间
  • 抢占式：高优先级的线程抢占CPU
• Java的调度方法
  • 同优先级线程组成先进先出队列（先到先服务），使用时间片轮转策略
  • 对高优先级，使用优先调度的抢占式策略

线程的优先级

• 线程的优先级等级
  • MAX_PRIORITY: 10
  • MIN_PRIORITY: 1
  • NORM PRIORITY: 5 --> 默认优先级
• 涉及的方法
  • getPriority(): 返回线程优先值
  • setPriority(int newPriority): 改变线程的优先级
• 说明
  • 线程创建时继承父线程的优先级
  • 低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用

多线程的创建，方式二：实现Runnable接口

1. 创建一个实现了Runnable接口的类
2. 实现类去实现Runnable中的抽象方法：run()
3. 创建实现类的对象
4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
5. 通过Thread类的对象调用start()：①启动线程；②调用当前线程的run() --> 调用了Runnable类型的target的run()

Thread类有一个Runnable类型的属性target
Thread类中的run()方法定义：

@Override
public void run(){
	if(target != null){
		target.run();
	}
}

实现Runnable接口法的例子：

// 1. 创建一个实现了Runnable接口的类
class MThread implements Runnable{
	// 2. 实现类去实现Runnable中的抽象方法：run()
	@Override
	public void run() {
		for(int i=0;i<100;i++){
			if(i%2==0){
				System.out.println(i);
			}
		}		
	}
}
public class Sample {
	public static void main(String[] args) {
		// 3. 创建实现类的对象
		MThread mThread = new MThread();
		// 4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
		Thread t1 = new Thread(mThread);
		// 5. 通过Thread类的对象调用start()
		t1.start();
	}
}

继承Thread法和实现Runnable接口法的比较

开发中：优先选择实现Runnable接口的方式
原因：
1、实现的方式没有类的单继承性的局限
2、实现的方式更适合来处理多个线程有共享数据的情况

联系：Thread类本身实现了Runnable接口
Thread类的定义：public class Thread implements Runnable

相同点：两种方式都需要重写run()，将线程要执行的逻辑声明在run()中
不同点：
1、继承Thread法是重写Thread类中的run()方法
2、实现Runnable接口法是将一个实现了Runnable接口的类的对象赋值给Thread类中的target，因此调用线程run()方法时会调用target的run()方法

补充：
1、线程通信使用到的三个方法：wait(), notify(), notifyAll()，这三个方法是在Object类中定义的，并不是Thread类中的方法
2、线程的分类：
Java中的线程分为两类：一种是守护线程，一种是用户线程
它们几乎每个方面都是相同的，唯一的区别是判断JVM何时离开
守护线程是用来服务用户线程的，通过在start()方法前调用thread.setDaemon(true)可以把一个用户线程变成一个守护线程。
Java垃圾回收就是一个典型的守护线程。
若JVM中都是守护线程，当前JVM将退出。

线程的生命周期

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

要想实现多线程，必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五种状态：

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

线程的同步

问题的提出：

• 多个程序执行的不确定性引起执行结果的不稳定
• 多个程序对账本的共享，会造成操作的不完整性，会破坏数据

以一个例子说明多线程安全问题：设有三个窗口同时卖票，票数总共10张，且每张票上带有编号。

未解决多线程安全问题的代码：

1、使用实现Runnable接口法

//未解决线程同步问题的卖票例子-- 使用实现Runnable接口法
class Window implements Runnable {
	private int ticket = 10;

	@Override
	public void run() {
		while (ticket > 0) {
			//这里加上sleep的目的只是为了提高线程切换的概率
			//没加sleep也可能出现线程切换的现象，只是概率相对较低
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + "卖编号为" + ticket + "的票");
			ticket--;
		}
	}
}

public class Sample {
	public static void main(String[] args) {
		Window w = new Window();
		Thread w1 = new Thread(w);
		w1.setName("窗口1");
		Thread w2 = new Thread(w);
		w2.setName("窗口2");
		Thread w3 = new Thread(w);
		w3.setName("窗口3");

		w1.start();
		w2.start();
		w3.start();
	}
}

2、使用继承Thread法

//未解决线程同步问题的卖票例子 -- 使用继承Thread法
class Window extends Thread {
	private static int ticket = 10; // ticket需要声明为static

	@Override
	public void run() {
		while (ticket > 0) {
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + "卖编号为" + ticket + "的票");
			ticket--;
		}
	}
}

public class Sample {
	public static void main(String[] args) {
		Thread w1 = new Window();
		w1.setName("窗口1");
		Thread w2 = new Window();
		w2.setName("窗口2");
		Thread w3 = new Window();
		w3.setName("窗口3");

		w1.start();
		w2.start();
		w3.start();
	}
}

输出：

此时出现了两个问题
1、有时候窗口出现了出售编号为一样的票，如编号10、编号7、编号4被售卖了多次，同时存在一些未被售卖出的票编号
2、最后一句输出出现了编号为-1的票

分析：
1、多线程出现了安全问题
2、出现问题的原因：当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错误。
3、解决方法：对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程都不可以参与执行（即使正在执行的线程出现了阻塞）。

在Java中，我们通过同步机制，来解决线程的安全问题

方式一：同步代码块

使用了同步代码块的代码：
（注意：在尚硅谷视频中，把sleep方法放在了需要被同步的代码之内，但我发现这样子做的话会导致输出中卖票窗口都是同一个窗口，所以我把sleep方法放在了需要被同步的代码之外，就解决了这个问题）
1、实现Runnable接口法

//使用同步代码块解决了线程同步问题的卖票例子 -- 使用实现Runnable接口法
class Window implements Runnable {
	private int ticket = 10;
	Object obj = new Object();

	@Override
	public void run() {
		// Object obj = new Object(); 这个声明语句放这里是错的，因为这样子每一个线程运行的时候会声明一个新的对象，因此做锁的不是同一个对象
		while (true) {
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			// syochronized(new Object()) 错误写法，因为不是同一个对象，多个线程没有共用同一把锁
			synchronized (obj) {
				if (ticket > 0) {
					System.out.println(Thread.currentThread().getName() + "卖编号为" + ticket + "的票");
					ticket--;
				} else {
					break;
				}
			}
		}
	}
}

public class Sample {
	public static void main(String[] args) {
		Window w = new Window();
		Thread w1 = new Thread(w);
		w1.setName("窗口1");
		Thread w2 = new Thread(w);
		w2.setName("窗口2");
		Thread w3 = new Thread(w);
		w3.setName("窗口3");

		w1.start();
		w2.start();
		w3.start();
	}
}

2、使用继承Thread法

//使用同步代码块解决了线程同步问题的卖票例子 -- 使用继承Thread法
class Window extends Thread {
	private static int ticket = 10; // ticket需要声明为static
	private static Object obj = new Object();// 注意这里obj需要声明为static才是使用了同一把锁，若没声明为static则不是用同一把锁，没法做到线程同步

	@Override
	public void run() {
		while (true) {
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			synchronized (obj) {
				if (ticket > 0) {
					System.out.println(Thread.currentThread().getName() + "卖编号为" + ticket + "的票");
					ticket--;
				} else {
					break;
				}
			}
		}
	}
}

public class Sample {
	public static void main(String[] args) {
		Thread w1 = new Window();
		w1.setName("窗口1");
		Thread w2 = new Window();
		w2.setName("窗口2");
		Thread w3 = new Window();
		w3.setName("窗口3");

		w1.start();
		w2.start();
		w3.start();
	}
}

输出：

可见安全问题解决了

补充：在上述使用了同步代码块中，如果是使用实现Runnable接口法，则还可以将synchronized语句写成以下形式

synchronized (this)

因为这个时候this是Window类的对象，因为只有一个Window类对象，所以可以作为锁（同步监视器）
但是在继承Thread法中就不可以这样写，因为是有多个Windows类对象，作为锁的不是同一个对象

除此之外，甚至这样可以写

synchronized (Window.class)

这个写法在实现Runnable接口法和继承Thread法都是可以用的。
这说明：类也是对象（这个内容在后面反射中会讲到）

方式二：同步方法

1、同步方法仍然涉及到同步监视器，只是不需要我们显式地声明
2、非静态的同步方法，同步监视器是：this
      静态的同步方法，同步监视器是：当前类本身

使用同步方法的代码（同理以下代码也是把sleep方法放在了需要被同步的代码之外）：
1、实现Runnable接口法（注意这个使用同步监视器是this）

//使用同步方法解决了线程同步问题的卖票例子 -- 使用实现Runnable接口法
class Window implements Runnable {
	private int ticket = 10;

	@Override
	public void run() {

		while (ticket > 0) {
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			show();
		}
	}

	private synchronized void show() { // 同步监视器：this
		if (ticket > 0) {
			System.out.println(Thread.currentThread().getName() + "卖编号为" + ticket + "的票");
			ticket--;
		}
	}
}

public class Sample {
	public static void main(String[] args) {
		Window w = new Window();
		Thread w1 = new Thread(w);
		w1.setName("窗口1");
		Thread w2 = new Thread(w);
		w2.setName("窗口2");
		Thread w3 = new Thread(w);
		w3.setName("窗口3");

		w1.start();
		w2.start();
		w3.start();
	}
}

2、继承Thread法

//使用同步方法解决了线程同步问题的卖票例子 -- 使用继承Thread法
class Window extends Thread {
	private static int ticket = 10; // ticket需要声明为static

	@Override
	public void run() {
		while (ticket > 0) {
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			show();
		}
	}

	private static synchronized void show() {//同步监视器：Window.class
		// private synchronized void show(){ 没注明static的话同步监视器是w1,w2,w3，不是同一个锁，是错误的
		if (ticket > 0) {
			System.out.println(Thread.currentThread().getName() + "卖编号为" + ticket + "的票");
			ticket--;
		}
	}
}

public class Sample {
	public static void main(String[] args) {
		Thread w1 = new Window();
		w1.setName("窗口1");
		Thread w2 = new Window();
		w2.setName("窗口2");
		Thread w3 = new Window();
		w3.setName("窗口3");

		w1.start();
		w2.start();
		w3.start();
	}
}

输出：

使用同步的利弊

好处：解决了线程的安全问题
坏处：操作同步代码时，只能有一个线程参与，其他线程等待，相当于是一个单线程的过程，效率较低

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

示例：

未考虑线程安全的单例模式：

class Bank {
	private Bank() {
	};

	private static Bank instance = null;

	public static Bank getInstance() {
		//注意在这里可能出现线程安全问题
		//有可能在Instance为null时，当线程1执行到这里，然后新建一个Bank对象
		//但是就在线程1未执行完代码时，线程2也执行到这里，这时候Instance也为null，线程2也新建一个Bank对象
		if (instance == null) {
			instance = new Bank();
		}
		return instance;
	}
}

方式一：效率较差的线程同步做法

1、使用同步方法：直接将getInstance方法定义改为

public static synchronized Bank getInstance()

2、使用同步代码块法：将getInstance方法体修改为：

public static Bank getInstance() {
		synchronized (Bank.class) {
			if (instance == null) {
				instance = new Bank();
			}
			return instance;
		}
	}

为什么说以上两种写法写效率较低？因为这样当创建了instance实例后，之后的线程要获取instance对象都要排队经过同步代码块，但此时已经不存在线程的安全问题了，每个线程都可以直接获取instance对象

方式二：效率较高的写法

将getInstance方法体修改为：

public static Bank getInstance() {
		if (instance == null) {
			synchronized (Bank.class) {
				if (instance == null) {
					instance = new Bank();
				}
			}
		}
		return instance;
	}

这种写法下，只有instance为null时才需要进行处理线程的同步问题，当instance不为null时所有线程都可以直接获取instance对象

在笔试中如果遇到了需要写单例模式的题，不管有没有提到需要写线程安全的，要么就直接写饿汉式，要么就写个线程安全的懒汉式

线程的死锁问题

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

解决方法
·专门的算法、原则
·尽量减少同步资源的定义
·尽量避免嵌套同步

死锁的示例（s1、s2都是锁且都被占用着）：

public class Sample {
	public static void main(String[] args) {
		StringBuffer s1 = new StringBuffer();
		StringBuffer s2 = new StringBuffer();
		new Thread() {
			public void run() {
				synchronized (s1) {
					s1.append("a");
					s2.append("1");
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					synchronized (s2) {
						s1.append("b");
						s2.append("2");
					}
				}
			}
		}.start();

		new Thread(new Runnable() {
			public void run() {
				synchronized (s1) {
					s1.append("c");
					s2.append("3");
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					synchronized (s2) {
						s1.append("d");
						s2.append("4");
					}
				}
			}
		}).start();
	}
}

Lock(锁)方式解决线程安全问题

从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。

java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。 锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。

ReentrantLock类实现了Lock ，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。

Lock的使用：
1、实例化ReentrantLock
2、调用锁定方法lock()
3、调用解锁方法unlock()

使用Lock锁解决窗口售票问题：

import java.util.concurrent.locks.ReentrantLock;

class Window implements Runnable {
	private int ticket = 10;

	// 1、实例化ReentrantLock
	private ReentrantLock lock = new ReentrantLock();

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

public class Sample {
	public static void main(String[] args) {
		Window w = new Window();
		Thread w1 = new Thread(w);
		w1.setName("窗口1");
		Thread w2 = new Thread(w);
		w2.setName("窗口2");
		Thread w3 = new Thread(w);
		w3.setName("窗口3");

		w1.start();
		w2.start();
		w3.start();
	}
}

面试题：synchronized和Lock的异同？
相同点：两者都可以解决线程安全问题
不同点：
1、synchronized是隐式锁，出了作用域会自动释放同步监视器
    Lock是显式锁，需要手动地启动同步（lock()），同时结束同步也需要手动的实现（unlock()）
2、Lock只有代码块锁，synchronized有代码块锁和方法锁
3、使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）

优先使用顺序：
Lock → 同步代码块（已经进入了方法体，分配了相应资源）→ 同步方法（在方法体之外）

面试题：如何解决线程安全问题？有几种方式？

线程的通信

线程通信涉及到的三个方法：wait()、notify()、notifyAll()

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

说明：

• wait()、notify()、notifyAll()三个方法必须使用在同步代码块或同步方法中（不能是在Lock法中使用，Lock使用线程通信有别的方式）
• wait()、notify()、notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器，否则会出现IllegalMonitorStateException异常
• wait()、notify()、notifyAll()三个方法是在java.lang.Object类中定义的，不是在Thread类中定义

 
示例：创建两个线程，交替打印从1到10的数字

1、使用this做同步监视器

class Number implements Runnable {
	private int number = 1;

	@Override
	public void run() {
		while (true) {
			synchronized (this) {
				// 使得调用如下notify()方法使得另一个线程退出阻塞状态
				notify();
				if (number <= 10) {
					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName() + " : " + number);
					number++;
					try {
						// 使得调用如下wait()方法的线程进入阻塞状态
						wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				} else {
					break;
				}
			}
		}
	}

}

public class Sample {
	public static void main(String[] args) {
		Number number = new Number();
		Thread t1 = new Thread(number);
		Thread t2 = new Thread(number);
		t1.setName("线程1");
		t2.setName("线程2");
		t1.start();
		t2.start();
	}
}

2、使用一个Object类对象做同步监视器（与上面代码的区别已注明）

class Number implements Runnable {
	private int number = 1;
	private Object obj = new Object();

	@Override
	public void run() {
		while (true) {
			synchronized (obj) {//修改部分
				obj.notify();//修改部分
				if (number <= 10) {
					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName() + " : " + number);
					number++;
					try {
						obj.wait();//修改部分
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				} else {
					break;
				}
			}
		}
	}

}

public class Sample {
	public static void main(String[] args) {
		Number number = new Number();
		Thread t1 = new Thread(number);
		Thread t2 = new Thread(number);
		t1.setName("线程1");
		t2.setName("线程2");
		t1.start();
		t2.start();
	}
}

输出：

sleep() 和 wait() 的异同

这个问题是经典的面试题

相同点：一旦执行这两个方法，都可以使得当前的线程进入阻塞状态
不同点：
1、两个方法声明的位置不同：Thread类中声明sleep()，Object类中声明wait()
2、调用的要求不同：sleep()可以在任何需要的场景下调用，wait()必须在同步代码块或同步方法中调用
3、关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁

这类面试题（长得比较像的）还有：
· throw和throws有什么区别
· final和finally有什么区别
· 重写跟重载有什么区别
· String和StringBuffer有什么区别

经典例题：生产者 / 消费者问题

生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，店员一次只能持有固定数量的产品（比如:20），如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。

这里可能出现两个问题:
1、生产者比消费者快时，消费者会漏掉一些数据没有取到。
2、消费者比生产者快时，消费者会取相同的数据。

分析：
1、是否是多线程问题？ 是，生产者线程，消费者线程
2、是否有共享数据？ 是，店员（或产品）
3、如何解决线程的安全问题？ 同步机制，有三种方法
4、是否涉及到线程通信？ 是

未解决线程安全问题的代码：

class Clerk {

	private int productCount = 0;

	// 生产产品
	public void produceProduct() {
		if (productCount < 20) {
			productCount++;
			System.out.println(Thread.currentThread().getName() + " : 开始生产第" + productCount + "个产品");
		} else {
		}
	}

	// 消费产品
	public void consumeProduct() {
		if (productCount > 0) {
			System.out.println(Thread.currentThread().getName() + " : 开始消费第" + productCount + "个产品");
			productCount--;
		} else {
		}
	}

}

class Producer extends Thread {
	private Clerk clerk;

	public Producer(Clerk clerk) {
		this.clerk = clerk;
	}

	@Override
	public void run() {
		System.out.println(getName() + " : 开始生产产品...");
		while (true) {
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			clerk.produceProduct();
		}
	}
}

class Consumer extends Thread {
	private Clerk clerk;

	public Consumer(Clerk clerk) {
		this.clerk = clerk;
	}

	@Override
	public void run() {
		System.out.println(getName() + " : 开始消费产品...");
		while (true) {
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			clerk.consumeProduct();
		}
	}
}

public class Sample {
	public static void main(String[] args) {
		Clerk clerk = new Clerk();

		Producer p1 = new Producer(clerk);
		p1.setName("生产者1");

		Consumer c1 = new Consumer(clerk);
		c1.setName("消费者1");

		p1.start();
		c1.start();
	}
}

解决了线程安全问题的代码（修改clerk类，修改处已注明）：

class Clerk {

	private int productCount = 0;

	// 生产产品
	public synchronized void produceProduct() {//修改处
		if (productCount < 20) {
			productCount++;
			System.out.println(Thread.currentThread().getName() + " : 开始生产第" + productCount + "个产品");
			notify();//修改处
		} else {
			try {
				wait();//修改处
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

	// 消费产品
	public synchronized void consumeProduct() {//修改处
		if (productCount > 0) {
			System.out.println(Thread.currentThread().getName() + " : 开始消费第" + productCount + "个产品");
			productCount--;
			notify();//修改处
		} else {
			try {
				wait();//修改处
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

}

JDK5.0新增线程创建方式

新增方式一：实现Callable接口

与使用Runnable相比，Callable功能更强大些

• 相比run()方法，可以有返回值
• 方法可以抛出异常
• 支持泛型的返回值
• 需要借助FutureTask类，比如获取返回结果

 
Future接口

• 可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。
• FutrueTask是Futrue接口的唯一的实现类
• FutureTask同时实现了Runnable, Future接口。它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值

如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程强大？
1、call()可以有返回值
2、call()可以抛出异常，被外面的操作捕获，获取异常的信息
3、Callable支持泛型

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

示例代码（找出20以内的偶数并求它们的和）：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

//1、创建一个实现Callable的实现类
class NumThread implements Callable {
	//2、实现call方法，将此线程需要执行的操作声明在call()中
	@Override
	public Object call() throws Exception {
		int sum = 0;
		System.out.println("20以内的偶数有：");
		for (int i = 1; i <= 20; i++) {
			if (i % 2 == 0) {
				System.out.print(i + " ");
				sum += i;
			}
		}
		System.out.println();
		return sum;
	}

}

public class Sample {
	public static void main(String[] args) {
		//3、创建Callable接口实现类的对象
		NumThread numThread = new NumThread();
		//4、将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask对象
		FutureTask futureTask = new FutureTask(numThread);
		//5、将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
		new Thread(futureTask).start();
		try {
			//6、获取Callable中call方法的返回值
			// get()返回值即为FutureTask构造器参数Callable实现类重写的call的返回值
			Object sum = futureTask.get();
			System.out.println("它们的和是：" + sum);
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (ExecutionException e) {
			e.printStackTrace();
		}
	}
}

输出：

新增方式二：使用线程池

背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程,对性能影响很大。

思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。

好处：
· 提高响应速度（减少了创建新线程的时间)
· 降低资源消耗（重复利用线程池中线程，不需要每次都创建)
· 便于线程管理
  · corePoolSize：核心池的大小
  · maximumPoolSize：最大线程数
  · keepAliveTime：线程没有任务时最多保持多长时间后会终止

 
线程池相关API：

JDK 5.0起提供了线程池相关API：ExecutorService 和 Executors

ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor

• void execute(Runnable command)：执行任务/命令，没有返回值，一般用来执行
  Runnable
• Future submit(Callable task)：执行任务，有返回值，一般用来执行
  Callable
• void shutdown()：关闭连接池

Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池

• Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
• Executors.newFixedThreadPool(n)：创建一个可重用固定线程数的线程池
• Executors.newSingleThreadExecutor()：创建一个只有一个线程的线程池
• Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行

示例（用两个线程分别找出10以内的奇数和偶数）：

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class EvenThread implements Runnable {

	@Override
	public void run() {
		for (int i = 0; i <= 10; i++) {
			if (i % 2 == 0) {
				System.out.println(Thread.currentThread().getName() + " : " + i);
			}
		}
	}

}

class OddThread implements Runnable {

	@Override
	public void run() {
		for (int i = 0; i <= 10; i++) {
			if (i % 2 == 1) {
				System.out.println(Thread.currentThread().getName() + " : " + i);
			}
		}
	}

}

public class Sample {
	public static void main(String[] args) {
		// 1、提供指定线程数量的线程池
		ExecutorService service = Executors.newFixedThreadPool(10);
		// 2、执行指定的线程的才做。需要提供实现Runnable接口或Callable接口实现类的对象
		service.execute(new EvenThread());// execute适合使用于Runnable
		service.execute(new OddThread());
		// service.submit(Callable callable);//submit适合使用于Callable

		// 3、关闭连接池
		service.shutdown();

	}
}

输出：

写在最后：
面试题：创建多线程有几种方式？
答：四种！！！（继承Thread法、实现Runnable接口法、实现Callable接口法、使用线程池法）