JAVA第十一课：多线程

1. 多线程

(1)多进程
	进程：正在执行的应用程序。
		正在运行的程序，是系统进行资源分配和调用的独立单位。
		每一个进程都有它自己的内存空间和系统资源。
	多进程的意义?
		单进程计算机只能做一件事情。
		而我们现在的计算机都可以一边玩游戏(游戏进程),一边听音乐(音乐进程)，
		所以我们常见的操作系统都是多进程操作系统。比如：Windows，Mac和Linux等，能在同一个时间段内执行多个任务。
		对于单核计算机来讲，游戏进程和音乐进程是同时运行的吗? 不是。
		因为CPU在某个时间点上只能做一件事情，计算机是在游戏进程和音乐进程间做着频繁切换，
		且切换速度很快，所以，我们感觉游戏和音乐在同时进行，其实并不是同时执行的。
		多进程的作用不是提高执行速度，而是提高CPU的使用率。
(2)多线程
	线程：进程的执行路径，执行单元，依赖于进程存在的。
		在一个进程内部又可以执行多个任务，而这每一个任务我们就可以看成是一个线程。
		线程是进程中的单个顺序控制流，是一条执行路径，是程序使用CPU的基本单位。
		一个进程如果只有一条执行路径，则称为单线程程序。
		一个进程如果有多条执行路径，则称为多线程程序。
	多线程的意义?
		多线程的作用不是提高执行速度，而是为了提高应用程序的使用率。
		而多线程却给了我们一个错觉：让我们认为多个线程是并发执行的。其实不是。
		因为多个线程共享同一个进程的资源(堆内存和方法区)，但是栈内存是独立的，
		一个线程一个栈。所以他们仍然是在抢CPU的资源执行。
		一个时间点上只有能有一个线程执行。而且谁抢到，这个不一定，所以，造成了线程运行的随机性。
	
	随机性原理：
		因为多个线程不断去抢CPU的资源，CPU就在这多个线程间进行快速的切换，造成了随机性。
		
(3)并行和并发
	并行：逻辑上同时发生，指在某一个时间内同时运行多个程序
	并发：物理上同时发生，指在某一个时间点同时运行多个程序
	
(4)多线程的实现方案
	A:继承Thread类
		步骤：
		a:自定义类MyThread继承自Thread类
		b:重写run()方法
			因为run()方法封装的代码才是被线程执行的代码。
		c:创建子类对象
		d:启动线程
			启动线程使用的是那个方法呢?
			start():启动线程，并自动调用run()方法。
		
		Thread类的基本获取和设置方法
			public final String getName()
			public final void setName(String name)
			通过构造方法也可以给线程起名字
			如果没有设置名称，会有一个默认名称。Thread-编号
		如何获取main方法所在的线程名称呢?
			public static Thread currentThread()
			这样就可以获取任意方法所在的线程名称
	B:实现Runnable接口
		步骤：
		a:定义类MyRunnable实现接口Runnable
		b:重写run()方法
		c:创建MyRunnable的对象
		d:创建Thread类的对象，并把C步骤的对象作为构造参数传递
		e:启动线程
		实现接口方式的好处：
			可以避免由于Java单继承带来的局限性。
			适合多个相同程序的代码去处理同一个资源的情况，把线程同程序的代码，
			数据有效分离，较好的体现了面向对象的设计思想。
(5)常见的几个小问题
	A:为什么要重写run()方法
	B:启动线程使用的是哪个方法
	C:start()和run()方法的区别
		start:启动线程，并自动调用run()方法
		run:直接调用，仅仅是普通方法的调用
	D:一个线程能不能启动多次? 不能
	E:有了继承Thread类实现，为什么还要有实现接口的实现
	F:生命周期
	
(6)线程的调度
	假如我们的计算机只有一个 CPU，那么CPU在某一个时刻只能执行一条指令，
	线程只有得到CPU时间片，也就是使用权，才可以执行指令。
	线程调度：
		A:分时调度模型：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片
		B:抢占式调度模型：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的 CPU 时间片相对多一些。 
		Java使用的是抢占式调度模型。
	获取和设置线程的优先级：
		public final int getPriority()
		public final void setPriority(int newPriority)
		默认优先级是5
		优先级范围是1-10
		
(7)线程的控制
	A:线程休眠
		public static void sleep(long millis)
	B:线程加入
		public final void join()
	C:线程礼让
		public static void yield()
	D:守护线程
		当正在运行的线程都是守护线程时，Java 虚拟机退出。 
		public final void setDaemon(boolean on)
	E:中断线程
		public final void stop()
		public void interrupt()
		
(8)多线程的生命周期图（见下）
(9)通过多线程模拟电影院卖票
	A:继承Thread类
	B:实现Runnable接口
(10)通过多线程模拟电影院卖票(加入延迟)
	某电影院目前正在上映贺岁大片，共有100张票，而它有3个售票窗口售票，请设计一个程序模拟该电影院售票。
	A:相同的票卖多次
		CPU的一次执行必须是原子性操作
	B:出现了负数的票
		线程的随机性和延迟
		
(11)线程安全问题是如何产生的呢?
	A:多线程环境
	B:有共享数据
	C:多条语句操作共享数据
(12)解决方案：
	基本思想：让程序没有安全问题的环境。
	实现：把多个语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可。
	A:同步代码块
		格式：
			synchronized(对象) {
				需要被同步的代码;
			}
		对象可以是任意对象
		同步可以解决安全问题的根本原因就在那个对象上,该对象如同锁的功能。

	B:同步方法: 就是把同步关键字加到方法上
		非静态	对象是this
		静态	对象是当前类的字节码文件对象
		同步的前提
		多个线程
		多个线程使用的是同一个锁对象
		
	同步的好处
		同步的出现解决了多线程的安全问题。
	同步的弊端
		当线程相当多时，因为每个线程都会去判断同步上的锁，很耗费资源，无形中会降低程序的运行效率。
	如果锁对象是this，就可以考虑使用同步方法。
	否则能使用同步代码块的尽量使用同步代码块。	

(13)查看源码，回顾前面的线程安全问题
	StringBuffer/StringBuilder
	Vector
	Hashtable
	以及Collections中的让集合同步功能。

JDK5中Lock锁的使用
	虽然我们可以理解同步代码块和同步方法的锁对象问题，
	但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，
	为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock
	Lock
		void lock()
		void unlock()
	ReentrantLock

线程的生命周期图

多线程两种方式和常见小问题

线程的状态转换图

代码演示，以下代码按学习顺序来排列的

多线程初识

class Test{
	public static void main(String[] args){
		MyThread mt = new MyThread();
		mt.run();
		mt.run();
		System.out.println("===================");
		//2个 run()依次执行

		MyThread mt1 = new MyThread();
		MyThread mt2 = new MyThread();
		mt1.run();
		mt2.run();
		System.out.println("===================");
		//2个 MyThread()依次执行
		
		MyThread mt3 = new MyThread();
		MyThread mt4 = new MyThread();
		mt3.start();
		mt4.start();
		System.out.println("===================");
		//2个 MyThread()伪同步执行
	}
}

class MyThread extends Thread{
	@Override
	public void run(){
		for(int i=0; i<10; i++){
			System.out.println(getName()+"---hello"+i);
		}
	}
}

多线程线程名：无参+setXxx 或 带参

class Test{
	public static void main(String[] args){
		// 无参+setXxx()
		MyThread mt1 = new MyThread();
		MyThread mt2 = new MyThread();
		mt1.setName("张三");
		mt2.setName("李四");
		mt1.start();
		mt2.start();
		System.out.println("===================");

		// 带参
		MyThread mt3 = new MyThread("王五");
		MyThread mt4 = new MyThread("赵六");
		mt3.start();
		mt4.start();
		System.out.println(Thread.currentThread().getName() + "---AAA");
	
	}
}


class MyThread extends Thread{
	public MyThread() {
	}

	public MyThread(String name) {
		super(name);
	}

	@Override
	public void run(){
		for(int i=0; i<10; i++){
			System.out.println(getName()+"---hello"+i);
		}
	}
}

线程的优先级

class Test{
	public static void main(String[] args){
		ThreadPriority tp1 = new ThreadPriority();
		ThreadPriority tp2 = new ThreadPriority();
		ThreadPriority tp3 = new ThreadPriority();

		tp1.setName("tp1");
		tp2.setName("tp2");
		tp3.setName("tp3");

		//获取默认优先级
		System.out.println(tp1.getPriority());
		System.out.println(tp2.getPriority());
		System.out.println(tp3.getPriority());

		// 设置线程优先级
		// IllegalArgumentException
		// tp1.setPriority(1000);
		tp1.setPriority(1);
		tp2.setPriority(5);
		tp3.setPriority(10);
		
		System.out.println(tp1.getPriority());
		System.out.println(tp2.getPriority());
		System.out.println(tp3.getPriority());

		// 启动线程
		tp1.start();
		tp2.start();
		tp3.start();
	}
}

守护线程

class Test{
	public static void main(String[] args){
		Thread.currentThread().setName("刘备");
		ThreadDaemon td1 = new ThreadDaemon();
		ThreadDaemon td2 = new ThreadDaemon();

		td1.setName("关羽");
		td2.setName("张飞");

		// 设置守护线程:当正在运行的线程都是守护线程时,JVM退出。
		td1.setDaemon(true);
		td2.setDaemon(true);

		td1.start();
		td2.start();

		for (int x = 0; x < 5; x++) {
			System.out.println(Thread.currentThread().getName() + ":" + x);
		}
	}
}

class ThreadDaemon extends Thread{
	@Override
	public void run(){
		for(int i=0; i<10; i++){
			System.out.println(getName()+"---hello"+i);
		}
	}
}

线程加入

class Test{
	public static void main(String[] args){
		ThreadJoin tj1 = new ThreadJoin();
		ThreadJoin tj2 = new ThreadJoin();
		ThreadJoin tj3 = new ThreadJoin();

		tj1.setName("李渊");
		tj2.setName("李世民");
		tj3.setName("李元霸");

		tj1.start();
		try {
			tj1.join();//等待该线程终止
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

		tj2.start();
		tj3.start();
	}
}

class ThreadJoin extends Thread {
	@Override
	public void run() {
		for (int x = 0; x < 10; x++) {
			System.out.println(getName() + ":" + x);
		}
	}
}

中断线程

import java.text.SimpleDateFormat;
import java.util.Date;

class Test{
	public static void main(String[] args){
		ThreadKill tk = new ThreadKill();
		tk.start();

		try {
			Thread.sleep(3000);
			//tk.stop();		//直接死
			tk.interrupt();	//死后还可以写遗嘱
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

class ThreadKill extends Thread {
	@Override
	public void run() {
		System.out.println("开始执行："+ new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));

		try {
			Thread.sleep(10000);
		} catch (InterruptedException e) {
			// e.printStackTrace();
			System.out.println("我被杀死了");
		}

		System.out.println("结束执行："+ new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
	}
}

线程休眠

import java.text.SimpleDateFormat;
import java.util.Date;

public class Test {
	public static void main(String[] args) {
		ThreadSleep ts1 = new ThreadSleep();
		ThreadSleep ts2 = new ThreadSleep();
		ThreadSleep ts3 = new ThreadSleep();

		ts1.setName("和珅");
		ts2.setName("秦桧");
		ts3.setName("高俅");

		ts1.start();
		ts2.start();
		ts3.start();
	}
}

class ThreadSleep extends Thread {
	@Override
	public void run() {
		for (int x = 0; x < 10; x++) {
			System.out.println(getName()+ ":"+ x+ "---"+ new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));

			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

礼让线程

public class Test {
	public static void main(String[] args) {
		ThreadYield ty1 = new ThreadYield();
		ThreadYield ty2 = new ThreadYield();

		ty1.setName("ty1");
		ty2.setName("ty2");

		ty1.start();
		ty2.start();
	}
}
class ThreadYield extends Thread {
	@Override
	public void run() {
		for (int x = 0; x < 10; x++) {
			System.out.println(getName() + ":" + x);
			Thread.yield();//礼让线程,暂停当前正在执行的线程对象,并执行其他线程
		}
	}
}

线程实现方案二：实现Runnable接口

/*
 * 实现Runnable接口的步骤：
 * 
 * A:定义类MyRunnable实现接口Runnable
 * B:重写run()方法
 * C:创建MyRunnable的对象
 * D:创建Thread类的对象，并把C步骤的对象作为构造参数传递
 * E:启动线程
 * 
 * 有了继承Thread类的方式，为什么还要有实现Runnable接口的方式?
 * 原因是因为类是单继承。
 */
public class Test {
	public static void main(String[] args) {
		// 创建MyRunnable的对象
		MyRunnable my = new MyRunnable();

		// 创建Thread类的对象，并把C步骤的对象作为构造参数传递
		// Thread(Runnable target)
		// Thread(Runnable target, String name)
		Thread t1 = new Thread(my, "t1");
		Thread t2 = new Thread(my, "t2");

		t1.start();
		t2.start();
	}
}

class MyRunnable implements Runnable {
	@Override
	public void run() {
		for (int x = 0; x < 10; x++) {
			System.out.println(Thread.currentThread().getName() + ":" + x);
		}
	}
}

卖票问题实现一：继承Thread

public class Test {
	public static void main(String[] args) {
		MovieTicket mt1 = new MovieTicket();
		MovieTicket mt2 = new MovieTicket();
		MovieTicket mt3 = new MovieTicket();

		mt1.setName("窗口1");
		mt2.setName("窗口2");
		mt3.setName("窗口3");

		mt1.start();
		mt2.start();
		mt3.start();
	}
}

class MovieTicket extends Thread {
	private static int tickets = 100;

	@Override
	public void run() {
		while (true) {
			if (tickets > 0) {
				System.out.println(getName() + "正在出售第" + (tickets--) + "张票");
			}
		}
	}
}

卖票问题实现二：实现Runnable 接口

public class Test {
	public static void main(String[] args) {
		MovieTicket mt = new MovieTicket();

		Thread t1 = new Thread(mt, "窗口1");
		Thread t2 = new Thread(mt, "窗口2");
		Thread t3 = new Thread(mt, "窗口3");

		t1.start();
		t2.start();
		t3.start();
	}
}

class MovieTicket2 implements Runnable {
	private int tickets = 100;

	@Override
	public void run() {
		while (true) {
			if (tickets > 0) {
				System.out.println(Thread.currentThread().getName() + "正在出售第"+ (tickets--) + "张票");
			}
		}
	}
}

考虑延时问题，加入线程睡眠，却发现以下代码出现bug

bug：
A:相同的票出现了多次
	CPU的一次操作必须是原子性的
B:还出现了负数票的情况
	随机性和延迟导致的

public class Test {
	public static void main(String[] args) {
		MovieTicket mt = new MovieTicket();

		Thread t1 = new Thread(mt, "窗口1");
		Thread t2 = new Thread(mt, "窗口2");
		Thread t3 = new Thread(mt, "窗口3");

		t1.start();
		t2.start();
		t3.start();
	}
}

class MovieTicket implements Runnable {
	private int tickets = 100;

	@Override
	public void run() {
		while (true) {
			if (tickets > 0) {
				try {
					Thread.sleep(100);// t1进来了,t2进来了,t3进来了
				} catch (InterruptedException e) {
					e.printStackTrace();
				}

				System.out.println(Thread.currentThread().getName() + "正在出售第"+ (tickets--) + "张票");
			}
		}
	}
}

解决：
	方式一：同步代码块
	方式二：同步方法

方式一：同步代码块

public class Test {
	public static void main(String[] args) {
		MovieTicket mt = new MovieTicket();

		Thread t1 = new Thread(mt, "窗口1");
		Thread t2 = new Thread(mt, "窗口2");
		Thread t3 = new Thread(mt, "窗口3");

		t1.start();
		t2.start();
		t3.start();
	}
}

class MovieTicket implements Runnable {
	private int tickets = 100;

	@Override
	public void run() {
		while (true) {
			// t1,t2,t3
			// t1过来了，看到了同步代码块的锁标记，绿色标记(火车上厕所，过马路的红绿灯)
			// t2,t3都只能在这里等待
			synchronized (this) {
				// t1就进来了，立马修改标记为红色标记
				if (tickets > 0) {
					// 更符合现实情况
					try {
						Thread.sleep(100); // t1休息会
					} catch (InterruptedException e) {
						e.printStackTrace();
					}

					System.out.println(Thread.currentThread().getName()+ "正在出售第" + (tickets--) + "张票");
				}
			}
			// t1出来了，立马修改标记为绿色标记
		}
	}
}

方式二：同步方法

public class Test {
	public static void main(String[] args) {
		MovieTicket mt = new MovieTicket();

		Thread t1 = new Thread(mt, "窗口1");
		Thread t2 = new Thread(mt, "窗口2");
		Thread t3 = new Thread(mt, "窗口3");

		t1.start();
		t2.start();
		t3.start();
	}
}

class MovieTicket implements Runnable {
	private static int tickets = 100;
	private Object obj = new Object();
	private int x = 0;

	@Override
	public void run() {
		while (true) {
			if (x % 2 == 0) {
				synchronized (MovieTicket.class) {
					if (tickets > 0) {
						try {
							Thread.sleep(100);
						} catch (InterruptedException e) {
							e.printStackTrace();
						}

						System.out.println(Thread.currentThread().getName()+ "正在出售第" + (tickets--) + "张票");
					}
				}
			} else {
				sellTicket();
			}
			x++;
		}
	}

	private static synchronized void sellTicket() {
		if (tickets > 0) {
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}

			System.out.println(Thread.currentThread().getName() + "正在出售第"+ (tickets--) + "张票");
		}
	}
}

Lock锁

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/*
 * 为了更清楚的让我们知道是如何加锁和释放锁的，JDK5以后就提供了一个接口：Lock锁。
 * Lock
 * 		public void lock():加锁
 * 		public void unlock():释放锁
 * 实现类对象
 * 		public ReentrantLock()
 */
public class Test {
	public static void main(String[] args) {
		MovieTicket mt = new MovieTicket();

		Thread t1 = new Thread(mt, "窗口1");
		Thread t2 = new Thread(mt, "窗口2");
		Thread t3 = new Thread(mt, "窗口3");

		t1.start();
		t2.start();
		t3.start();
	}
}

class MovieTicket implements Runnable {
	private int tickets = 100;
	private Object obj = new Object();

	// 造锁
	// private ReentrantLock lock = new ReentrantLock();
	private Lock lock = new ReentrantLock();

	@Override
	public void run() {
		while (true) {
			try {
				lock.lock();// 加锁
				if (tickets > 0) {
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName()+ "正在出售第" + (tickets--) + "张票");
				}
			} finally {
				lock.unlock();// 释放锁
			}
		}
	}
}

2. 死锁

同步弊端
	效率低
	如果出现了同步嵌套，就容易产生死锁问题

死锁问题
	是指两个或者两个以上的线程在执行的过程中，因争夺资源产生的一种互相等待现象
	同步代码块的嵌套

class Test {
	public static void main(String[] args) {
		//死锁：是指两个或者两个以上的线程在执行的过程中，因争夺资源产生的一种互相等待现象
		DieLock d1 = new DieLock(true);
		DieLock d2 = new DieLock(false);

		d1.start();
		d2.start();
	}
}

class MyLock {
	public static final Object objA = new Object();
	public static final Object objB = new Object();
}

class DieLock extends Thread {
	private boolean flag;

	public DieLock(boolean flag) {
		this.flag = flag;
	}

	@Override
	public void run() {
		if (flag) {
			synchronized (MyLock.objA) {
				System.out.println("if objA"); // CPU的执行权没有了
				synchronized (MyLock.objB) {
					System.out.println("if objB");
				}
			}
		} else {
			synchronized (MyLock.objB) {
				System.out.println("else objB");
				synchronized (MyLock.objA) {
					System.out.println("else objA");
				}
			}
		}   
	}
}

3. 线程间通信

针对同一个资源的操作有不同种类的线程
举例：卖票有进的，也有出的。

通过设置线程(生产者)和获取线程(消费者)针对同一个学生对象进行操作

线程间通信的代码改进
	A:通过等待唤醒机制实现数据依次出现
		wait() 		让线程处于等待
		notify()	唤醒单个线程
		notifyAll() 唤醒所有线程
	B:把同步代码块改进为同步方法实现

等待唤醒机制

普通代码

public class Test {
	public static void main(String[] args) {
		Student s = new Student();

		SetThread st = new SetThread(s);
		GetThread gt = new GetThread(s);

		Thread t1 = new Thread(st);
		Thread t2 = new Thread(gt);

		t1.start();
		t2.start();
	}
}

class SetThread implements Runnable {
	private Student s;

	public SetThread(Student s) {
		this.s = s;
	}

	@Override
	public void run() {
		s.name = "林青霞";
		s.age = 28;
	}
}

class GetThread implements Runnable {
	private Student s;
	
	public GetThread(Student s) {
		this.s = s;
	}

	@Override
	public void run() {
		System.out.println(s.name + "---" + s.age);
	}
}

class Student {
	String name;
	int age;
}

加2个锁

public class Test {
	public static void main(String[] args) {
		Student s = new Student();

		SetThread st = new SetThread(s);
		GetThread gt = new GetThread(s);

		Thread t1 = new Thread(st);
		Thread t2 = new Thread(gt);

		t1.start();
		t2.start();
	}
}

class SetThread implements Runnable {
	private Student s;
	private int x = 0;

	public SetThread(Student s) {
		this.s = s;
	}

	@Override
	public void run() {
		while (true) {
			synchronized (s) {
				if (x % 2 == 0) {
					s.name = "林青霞";。
					s.age = 28;
				} else {
					s.name = "刘意";
					s.age = 31;
				}
				x++;
			}
		}
	}
}

class GetThread implements Runnable {
	private Student s;

	public GetThread(Student s) {
		this.s = s;
	}

	@Override
	public void run() {
		while (true) {
			synchronized (s) {
				System.out.println(s.name + "---" + s.age);
			}
		}
	}

}

class Student {
	String name;
	int age;
}

同步代码块 + 线程等待 & 唤醒线程

public class Test {
	public static void main(String[] args) {
		Student s = new Student();

		SetThread st = new SetThread(s);
		GetThread gt = new GetThread(s);

		Thread t1 = new Thread(st);
		Thread t2 = new Thread(gt);

		t1.start();
		t2.start();
	}
}

class SetThread implements Runnable {
	private Student s;
	private int x = 0;

	public SetThread(Student s) {
		this.s = s;
	}

	@Override
	public void run() {
		while (true) {
			synchronized (s) {
				if (s.flag) {//表示有数据
					try {
						s.wait(); // t1就等待了
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}

				if (x % 2 == 0) {
					s.name = "林青霞";
					s.age = 28;
				} else {
					s.name = "刘意";
					s.age = 31;
				}
				x++;
				s.flag = true;
				s.notify(); //唤醒等待的线程，并不代表该线程能够立即获取CPU的执行权
			}
		}
	}
}

class GetThread implements Runnable {
	private Student s;

	public GetThread(Student s) {
		this.s = s;
	}

	@Override
	public void run() {
		while (true) {
			synchronized (s) {
				if (!s.flag) {//如果没有数据，就等待
					try {
						s.wait(); //t2就等待了,释放了锁对象,从哪里跌倒从哪里爬起。
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				System.out.println(s.name + "---" + s.age);
				s.flag = false;
				s.notify();//唤醒单个线程
			}
		}
	}

}

class Student {
	String name;
	int age;
	boolean flag = false; // 表示是否有数据
}

同步方法

public class Test {
	public static void main(String[] args) {
		Student s = new Student();

		SetThread st = new SetThread(s);
		GetThread gt = new GetThread(s);

		Thread t1 = new Thread(st);
		Thread t2 = new Thread(gt);
		t1.start();
		t2.start();
	}
}

class SetThread implements Runnable {
	private Student s;
	private int x = 0;

	public SetThread(Student s) {
		this.s = s;
	}

	@Override
	public void run() {
		while (true) {
			if (x % 2 == 0) {
				s.set("林青霞", 28);
			} else {
				s.set("刘意", 31);
			}
			x++;
		}
	}
}

class GetThread implements Runnable {
	private Student s;
	public GetThread(Student s) {
		this.s = s;
	}

	@Override
	public void run() {
		while (true) {
			s.get();
		}
	}
}

class Student {
	private String name;
	private int age;
	private boolean flag = false; // 表示是否有数据

	public synchronized void set(String name, int age) {
		if (this.flag) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

		this.name = name;
		this.age = age;

		this.flag = true;
		this.notify();
	}

	public synchronized void get() {
		if (!this.flag) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println(this.name + "---" + this.age);

		this.flag = false;
		this.notify();
	}
}

4. 线程组

Java中使用ThreadGroup来表示线程组，它可以对一批线程进行分类管理，
Java允许程序直接对线程组进行控制。
默认情况下，所有的线程都属于主线程组。
	public final ThreadGroup getThreadGroup()
我们也可以给线程设置分组
	Thread(ThreadGroup group, Runnable target, String name) 

/*
 * 线程组：Java中使用ThreadGroup来表示线程组，它可以对一批线程进行分类管理，Java允许程序直接对线程组进行控制。
 * 
 * 默认情况下，所有的线程都属于主线程组。
 * public final ThreadGroup getThreadGroup()：返回该线程所属的线程组。 
 * public final String getName()			:返回此线程组的名称。  
 * Thread(ThreadGroup group, Runnable target, String name):设置线程组名称
 * public final int getMaxPriority()		:返回此线程组最高优先级
 */
public class Test {
	public static void main(String[] args) {
//		method1();
		method2();
	}

	// 设置线程所属的线程组
	private static void method2() {
		// public ThreadGroup(String name)
		ThreadGroup tg = new ThreadGroup("tg");
		tg.setDaemon(true);

		ThreadGroupRunnable tgr = new ThreadGroupRunnable();
		Thread t1 = new Thread(tg, tgr, "t1");
		Thread t2 = new Thread(tg, tgr, "t2");

		System.out.println(t1.getThreadGroup().getName());
		System.out.println(t2.getThreadGroup().getName()); 
		System.out.println(Thread.currentThread().getThreadGroup().getName());// main

		// 设置t1,t2为守护线程:JVM退出
		t1.setDaemon(true);
		t2.setDaemon(true);

		//tg.stop();
		System.out.println(tg.isDaemon());
		System.out.println(tg.getMaxPriority());
		System.out.println(tg.toString());

		tg.setMaxPriority(8);
		System.out.println(tg.getMaxPriority());
		System.out.println(t1.getPriority());
		System.out.println(t2.getPriority());

		t1.start();
		t2.start();
	}

	// 获取线程所在的线程组名称
	private static void method1() {
		ThreadGroupRunnable tgr = new ThreadGroupRunnable();

		Thread t1 = new Thread(tgr, "t1");
		Thread t2 = new Thread(tgr, "t2");

		// public final ThreadGroup getThreadGroup()
		ThreadGroup tg1 = t1.getThreadGroup();
		ThreadGroup tg2 = t2.getThreadGroup();

		String t1Name = tg1.getName();
		String t2Name = tg2.getName();

		System.out.println(t1Name); // main
		System.out.println(t2Name); // main

		System.out.println(Thread.currentThread().getThreadGroup().getName()); // main

		 t1.start();
		 t2.start();
	}
}

class ThreadGroupRunnable implements Runnable {

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

5. 线程池

程序启动一个新线程成本是比较高的，因为它涉及到要与操作系统进行交互。而使用线程池可以很好的提高性能，尤其是当程序中要创建大量生存期很短的线程时，更应该考虑使用线程池。
线程池里的每一个线程代码结束后，并不会死亡，而是再次回到线程池中成为空闲状态，等待下一个对象来使用。
在JDK5之前，我们必须手动实现自己的线程池，从JDK5开始，Java内置支持线程池

JDK5新增了一个Executors工厂类来产生线程池，有如下几个方法
	public static ExecutorService newCachedThreadPool()
	public static ExecutorService newFixedThreadPool(int nThreads)
	public static ExecutorService newSingleThreadExecutor()
这些方法的返回值是ExecutorService对象，该对象表示一个线程池，可以执行Runnable对象或者Callable对象代表的线程。它提供了如下方法
	Future<?> submit(Runnable task)
	<T> Future<T> submit(Callable<T> task)
案例演示
	创建线程池对象
	创建Runnable实例
	提交Runnable实例
	关闭线程池
	
public static ExecutorService newCachedThreadPool()
创建一个具有缓存功能的线程池
缓存：百度浏览过的信息再次访问
public static ExecutorService newFixedThreadPool(int nThreads)
创建一个可重用的，具有固定线程数的线程池
public static ExecutorService newSingleThreadExecutor()
创建一个只有单线程的线程池，相当于上个方法的参数是1		


多线程程序实现方案3
	实现Callable接口
		步骤和线程池执行Runnable对象的差不多。
		但是还可以更好玩一些，求和案例演示
	好处：
		可以有返回值
		可以抛出异常
	弊端：
		代码比较复杂，所以一般不用


匿名内部类方式使用多线程
	new Thread(){代码…}.start();
	New Thread(new Runnable(){代码…}).start();
代码演示：
	new Thread() {
		public void run() {
			for (int x = 0; x < 100; x++) {
				System.out.println(getName() + "---" + x);
			}
		};
	}.start();

	new Thread(new Runnable() {
		@Override
		public void run() {
			for (int x = 0; x < 100; x++) {
				System.out.println(Thread.currentThread().getName() + "---"+ x);
			}
		}
	}).start();

线程池

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

/*
 * 线程池：线程池里的每一个线程代码结束后，并不会死亡，而是再次回到线程池中成为空闲状态，等待下一个对象来使用。
 * 
 * 步骤：
 * 		A:定义类MyRunnable实现Runnable接口
 * 		B:创建MyRunnable对象
 * 		C:创建线程池对象
 * 		D:提交
 * 		E:释放
 */
public class Test {
	public static void main(String[] args) {
		MyRunnable my = new MyRunnable();

		// 创建线程池对象
		// public static ExecutorService newFixedThreadPool(int nThreads)
		ExecutorService pool = Executors.newFixedThreadPool(5);

		// 提交代码
		// Future<?> submit(Runnable task)
		pool.submit(my);
		pool.submit(my);
		pool.submit(my);
		pool.submit(my);
		pool.submit(my);

		// 释放
		pool.shutdown();
	}
}

class MyRunnable implements Runnable {

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

多线程实现方案三：实现 Callable接口

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

/*
 * 线程池：线程池里的每一个线程代码结束后，并不会死亡，而是再次回到线程池中成为空闲状态，等待下一个对象来使用。
 * 
 * 步骤：
 * 		A:定义类MyCallable实现Callable接口
 * 		B:创建MyCallable对象
 * 		C:创建线程池对象
 * 		D:提交
 * 		E:释放
 */
public class Test {
	public static void main(String[] args) {
		MyCallable my = new MyCallable();

		// 创建线程池对象
		// public static ExecutorService newFixedThreadPool(int nThreads)
		ExecutorService pool = Executors.newFixedThreadPool(5);

		// 提交代码
		// Future<?> submit(Runnable task)
		pool.submit(my);
		pool.submit(my);
		pool.submit(my);
		pool.submit(my);
		pool.submit(my);

		// 释放
		pool.shutdown();
	}
}

class MyCallable implements Callable {

	@Override
	public Object call() throws Exception {
		for (int x = 0; x < 10; x++) {
			System.out.println(Thread.currentThread().getName() + ":" + x);
		}
		return null;
	}
}

求和案例：sum = 1+2+3+…+n

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/*
 * 求和案例:sum = 1+2+3+...+n
 */
public class Test {
	public static void main(String[] args) throws InterruptedException,ExecutionException {
		// 创建线程池对象
		ExecutorService pool = Executors.newFixedThreadPool(3);

		// 提交数据
		Future<Integer> f1 = pool.submit(new MyCallable(5));
		Future<Integer> f2 = pool.submit(new MyCallable(10));
		Future<Integer> f3 = pool.submit(new MyCallable(100));

		Integer i1 = f1.get();
		Integer i2 = f2.get();
		Integer i3 = f3.get();

		System.out.println(i1);
		System.out.println(i2);
		System.out.println(i3);

		pool.shutdown();
	}
}

class MyCallable implements Callable<Integer> {

	private int number;

	public MyCallable(int number) {
		this.number = number;
	}

	@Override
	public Integer call() throws Exception {
		int sum = 0;
		for (int x = 1; x <= number; x++) {
			sum += x;
		}
		return sum;
	}
}

匿名内部类的方式开启多线程程序

/*
 * 匿名内部类的方式开启多线程程序。
 * 
 * new 类名() {
 * 		重写方法
 * };
 */
public class Test {
	public static void main(String[] args) {
		/*new Thread() {
			@Override public void run() { 
				for (int x = 0; x < 10; x++) {
					System.out.println("t1:" + x); 
				} 
			} 
		}.start();
		
		new Thread() { 
			@Override public void run() { 
				for (int x = 0; x < 10; x++) {
					System.out.println("t2:" + x); 
				} 
			} 
		}.start();*/
		

		/*new Thread(new Runnable() {
			@Override public void run() { 
				for (int x = 0; x < 10; x++) {
					System.out.println("t3:" + x); 
				} 
			} 
		}).start();
		
		new Thread(new Runnable() {
			@Override public void run() { 
				for (int x = 0; x < 10; x++) {
					System.out.println("t4:" + x); 
				} 
			} 
		}).start();*/
		 

		// 面试
		new Thread(new Runnable() {
			@Override
			public void run() {
				for (int x = 0; x < 10; x++) {
					System.out.println("t5:" + x);
				}
			}
		}) {
			@Override
			public void run() {
				for (int x = 0; x < 10; x++) {
					System.out.println("t6:" + x);
				}
			}
		}.start();
	}
}

6. 定时器

定时器是一个应用十分广泛的线程工具，可用于调度多个定时任务以后台线程的方式执行。在Java中，可以通过Timer和TimerTask类来实现定义调度的功能
Timer
	public Timer()
	public void schedule(TimerTask task, long delay)
	public void schedule(TimerTask task,long delay,long period)
TimerTask
	public abstract void run()
	public boolean cancel()
无论是TimerTask类还是Timer类，其cancel()方法都是为了清除任务队列中的任务。
虽然都是清除任务队列中的任务，却有一些不同：
TimerTask类中的cancel()方法侧重的是将自身从任务队列中清除，其他任务不受影响，
而Timer类中的cancel()方法则是将任务队列中全部的任务清空。
开发中Quartz是一个完全由java编写的开源调度框架。
	1：演示3秒后执行某个动作，
	2：演示3秒后执行某个动作，然后每隔2秒执行某个动作
	3：可以把任务结束掉

import java.util.Timer;
import java.util.TimerTask;

/*
 * 定义任务由两个类来一起完成：
 * Timer,TimerTask
 * 
 * Timer:
 * 		public Timer()创建一个新计时器。
 */
public class Test {
	public static void main(String[] args) {
		// 创建定时器
		final Timer t = new Timer();

		// public void schedule(TimerTask task,long delay):在delay毫秒后完成task的任务
		// t.schedule(new MyTask(t), 3000);

		// 匿名内部类实现
		t.schedule(new TimerTask() {

			@Override
			public void run() {
				System.out.println("炸弹爆炸了,duang");
				t.cancel();//清空队列中全部任务
			}
		}, 3000);
	}
}

class MyTask extends TimerTask {
	private Timer t;

	public MyTask(Timer t) {
		this.t = t;
	}

	@Override
	public void run() {
		System.out.println("炸弹爆炸了");
		t.cancel();
	}
}

连环雷 和 定时雷

/*
 * 炸弹要连续炸
 */
public class Test {
	public static void main(String[] args) throws ParseException {
		Timer t = new Timer();

		// 启动任务
		t.schedule(new TimerTask() {
			@Override
			public void run() {
				System.out.println("要炸了，快跑");
			}
		}, 2000);

		//public void schedule(TimerTask task,long delay,long period):第一次是delay后启动，以后每次是period启动
		t.schedule(new TimerTask() {
			@Override
			public void run() {
				System.out.println("连环雷，炸死你");
			}
		}, 3000, 1000);

		// public void schedule(TimerTask task,Date time):在time时间执行一次
		// public void schedule(TimerTask task,Date time,long period)：在time时间开始第一次执行，以后每次period再启动
		String s = "2020-11-5 11:07:00";
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		Date d = sdf.parse(s);

		t.schedule(new TimerTask() {
			@Override
			public void run() {
				System.out.println("炸死你");
			}
		}, d,1000);
	}
}

class MyTask extends TimerTask {
	private Timer t;

	public MyTask(Timer t) {
		this.t = t;
	}

	@Override
	public void run() {
		System.out.println("炸弹爆炸了");
		t.cancel();
	}
}

7. 多线程面试题

多线程面试题
（1）多线程有几种实现方案，分别是哪几种?
（2）同步有几种方式，分别是什么?
（3）启动一个线程是run()还是start()?它们的区别?
（4）sleep()和wait()方法的区别
（5）为什么wait(),notify(),notifyAll()等方法都定义在Object类中
（6）线程的生命周期图

面试题答案

（1）多线程有几种实现方案，分别是哪几种?
答案：3种，但一般说2种常用的

1. 继承Thread类
2. 实现Runnable接口
3. 实现Callable接口,代码复杂，一般不使用
4. 匿名内部类也可以实现多线程

（2）同步有几种方式，分别是什么?
答案：2种

1. 同步代码块
2. 同步方法

（3）启动一个线程是run()还是start()?它们的区别?
答案：启动线程用 start();
区别：
run(): 封装了被线程执行的代码，直接调用仅仅是普通方法的调用
start(): 启动线程，并由JVM自动调用run()方法
注：start()方法被用来启动新创建的线程，而且start()内部调用了run()方法，这和直接调用run()方法的效果不一样。
当你调用run()方法的时候，只会是在原来的线程中调用，没有新的线程启动，start()方法才会启动新线程。

（4）sleep()和wait()方法的区别
答案：
sleep(): 必须指时间; 不释放锁。
wait(): 可以不指定时间，也可以指定时间; 释放锁

（5）为什么wait(),notify(),notifyAll()等方法都定义在Object类中
答案：

1. 这些方法存在与同步中。
2. 使用这些方法时必须要标识所属的同步的锁。
3. 锁可以是任意对象，所以任意对象调用的方法一定定义Object类中。

（6）线程的生命周期图

1. 新建（new）：处于该状态的时间很短暂。已被分配了必须的系统资源，并执行了初始化。表示有资格获得CPU时间。调度器可以把该线程变为runnable或者blocked状态
2. 就绪（Runnable）：这种状态下只要调度器把时间片分配给线程，线程就能运行。处在这种状态就是可运行可不运行的状态
3. 阻塞（Bolocked）：线程能够运行，但有个条件阻止它的运行。当线程处于阻塞状态时，调度器将会忽略线程，不会分配给线程任何CPU时间（例如sleep）。只有重新进入了就绪状态，才有可能执行操作。
4. 死亡（Dead）：处于死亡状态的线程讲不再是可调度的，并且再也不会得到CPU时间。任务死亡的通常方式是从run()方法返回。

一个任务进入阻塞状态，可能有如下原因：

1. sleep
2. wait()，知道线程得到了notify()或者notifyAll()消息，线程才会进入就绪状态。
3. 任务在等待某个输入/输出完成
4. 线程在试图在某个对象上调用其同步控制方法，但是对象锁不可用，因为另一个任务已经获取了这个锁。