目录
三.线程的生命周期
Java语言使用Thread类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五种状态：
1.新建
当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态。
2.就绪
处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源。
3.运行
当就绪的线程被调度并获得CPU资源时,便进入运行状态， run()方法定义了线程的操作和功能。
4.阻塞
在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态 。
5.死亡
线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束。
6.线程生命周期图
四.线程的同步
1.背景
例子：创建三个窗口卖票，总票数为100张.
1.问题：卖票过程中，出现了重票、错票 -->出现了线程的安全问题
2.问题出现的原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票。
3.如何解决：当一个线程a在操作ticket的时候，其他线程不能参与进来。直到线程a操作完ticket时，其他线程才可以开始操作ticket。这种情况即使线程a出现了阻塞，也不能被改变。
2.Java解决方案：同步机制
在Java中，通过同步机制，来解决线程的安全问题。Java提供了三种线程同步机制
- 同步代码块
- 同步方法
- 同步锁
①方式一：同步代码块
synchronized(同步监视器){
//需要被同步的代码
}
说明：1.操作共享数据的代码，即为需要被同步的代码。 -->不能包含代码多了，也不能包含代码少了。
2.共享数据：多个线程共同操作的变量。比如：ticket就是共享数据。
3.同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。
要求：多个线程必须要共用同一把锁。
补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。
在继承Thread类创建多线程的方式中，慎用this充当同步监视器，考虑使用当前类充当同步监视器。
/*
* 创建三个窗口卖票，总票数为100张，通过实现Runnable接口方式创建接口，使用同步代码块实现线程同步
*/
//1. 创建一个实现了Runnable接口的类
class Window1 implements Runnable{
private static int ticket=100;
Object obj=new Object();
// 2. 实现类去实现Runnable中的抽象方法：run()
@Override
public void run() {
while(true) {
// 同步代码块
// 补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。
// 在继承Thread类创建多线程的方式中，慎用this充当同步监视器，考虑使用当前类充当同步监视器。
synchronized(this) {
if(ticket>0) {
System.out.println(Thread.currentThread().getName()+"卖票，票号为"+(101-ticket));
ticket--;
}else
break;
}
}
}
}
public class Window2Test {
public static void main(String[] args) {
// 3. 创建实现类的对象
Window1 w=new Window1();
// 4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
Thread t1=new Thread(w);
Thread t2=new Thread(w);
Thread t3=new Thread(w);
//修改线程名称
t1.setName("窗口一");
t2.setName("窗口二");
t3.setName("窗口三");
// 5. 通过Thread类的对象调用start()
t1.start();
t2.start();
t3.start();
}
}②方式二：同步方法
如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的。
关于同步方法的总结：
1. 同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
2. 非静态的同步方法，同步监视器是：this
静态的同步方法，同步监视器是：当前类本身
/*
* 创建三个窗口卖票，总票数为100张,通过继承Thread类创建线程，使用同步方法的线程同步
*/
//1. 创建一个继承于Thread类的子类window1
class Window extends Thread{
private static int ticket= 100;
//2. 重写Thread类的run() --> 将此线程执行的操作声明在run()中
@Override
public void run() {
while(sellTicket()) {
}
}
//创建同步方法
//使用继承Thread类创建线程，需要将方法定义为静态方法
// 使用实现Runnable接口创建线程，需要将方法定义为非静态方法
private static synchronized boolean sellTicket() {
if(ticket>0) {
System.out.println(Thread.currentThread().getName()+"卖票，票号为"+(101-ticket));
ticket--;
return true;
}else
return false;
}
}
public class Window1Test {
public static void main(String[] args) {
//3.创建Thread类的子类的对象
Window w1=new Window();
Window w2=new Window();
Window w3=new Window();
//设置线程名称
w1.setName("窗口一");
w2.setName("窗口二");
w3.setName("窗口三");
//4. 通过此对象调用start()：①启动当前线程 ② 调用当前线程的run()
w1.start();
w2.start();
w3.start();
}
}
③方式三：同步锁
1.创建ReentrantLock类的私有常量对象
2.在保证线程安全的代码的前后分别加上对象.lock()和对象.unlock()
3.如果同步代码有异常，要将unlock()写入finally语句块
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
import java.util.concurrent.locks.ReentrantLock;
/*
* 创建三个窗口卖票，总票数为100张,通过实现Callable接口类创建线程，使用同步锁的方式实现线程同步
*/
//1.创建一个实现Callable的实现类Window3
class Window3 implements Callable{
private int ticket=100;
private final ReentrantLock lock=new ReentrantLock();
//2.实现call方法，将此线程需要执行的操作声明在call()中
@Override
public Object call() throws Exception {
while(true) {
lock.lock();
if(ticket>0) {
System.out.println(Thread.currentThread().getName()+"卖票，票号为"+(101-ticket));
ticket--;
}else
break;
lock.unlock();
}
return 100;
}
}
public class Window3Test {
public static void main(String[] args) {
// 3.创建Callable接口实现类Window3的对象
Window3 w=new Window3();
//4.将此Callable接口实现类Window3的对象作为传递到FutureTask构造器中，创建FutureTask的对象
FutureTask futureTask=new FutureTask(w);
//5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象
Thread t1=new Thread(futureTask);
Thread t2=new Thread(futureTask);
Thread t3=new Thread(futureTask);
//设置线程名
t1.setName("窗口一");
t2.setName("窗口二");
t3.setName("窗口三");
//6.用Thread对象并调用start()
t1.start();
t2.start();
t3.start();
//7.获取Callable中call方法的返回值
try {
//get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
Object back=futureTask.get();
System.out.println("返回值为："+back);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ExecutionException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
④synchronized 与 Lock 的对比
1. Lock是显式锁(手动开启和关闭锁，别忘记关闭锁)，synchronized是隐式锁，出了作用域自动释放
2. Lock只有代码块锁，synchronized有代码块锁和方法锁
3. 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性(提供更多的子类）
优先使用顺序： Lock >同步代码块（已经进入了方法体，分配了相应资源)>同步方法 (在方法体之外）
⑤线程安全的单例模式
单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。 如果我们要让类在一个虚拟机中只能产生一个对象，我们首先必须将类的构造器的访问权限设置为private，这样，就不能用new操作符在类的外部产生类的对象了，但在类内部仍可以产生该类的对象。因为在类的外部开始还无法得到类的对象，只能调用该类的某个静态方法以返回类内部创建的对象， 静态方法只能访问类中的静态成员变量，所以，指向类内部产生的该类对象的变量也必须定义成静态的。
方式一：效率较差
public class Bank {
private Bank(){
}
private static Bank instance=null;
public Bank getInstance() {
//方式一：效率稍差
synchronized(Bank.class) {
if(instance==null) {
instance=new Bank();
}
return instance;
}
}
}方式二：效率更高
public class Bank {
private Bank(){
}
private static Bank instance=null;
public Bank getInstance() {
//方式二：效率更高
if(instance==null) {
synchronized(Bank.class) {
if(instance==null) {
instance=new Bank();
}
}
}
return instance;
}
}⑥死锁
1.死锁的理解：
不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁2.说明：
a.出现死锁后，不会出现异常，不会出现提示，只是所的线程都处于阻塞状态，无法继续
b.我们使用同步时，要避免出现死锁。
public class DeadLock {
public static void main(String[] args) {
StringBuffer s1 = new StringBuffer();
StringBuffer s2 = new StringBuffer();
// 使用继承Thread类创建线程，生成匿名对象调用start();
new Thread(){
@Override
public void run() {
synchronized (s1){
s1.append("a");
s2.append("1");
// 线程休眠0.1s
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (s2){
s1.append("b");
s2.append("2");
System.out.println(s1);
System.out.println(s2);
}
}
}
}.start();
// 通过实现Runnable接口类创建线程，用匿名对象调用start();
new Thread(new Runnable() {
@Override
public void run() {
synchronized (s2){
s1.append("c");
s2.append("3");
// 线程休眠0.1s
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (s1){
s1.append("d");
s2.append("4");
System.out.println(s1);
System.out.println(s2);
}
}
}
}).start();
}
}
五.线程的通信
1.背景
生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，店员一次只能持有固定数量的产品(比如:20），如果生产者试图 生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。
这里可能出现两个问题：a.生产者比消费者快时，消费者会漏掉一些数据没有取到。b.消费者比生产者快时，消费者会取相同的数据。
2.线程的通信
①线程通信涉及的方法
1.线程通信涉及到的三个方法：
wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
notify():一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个。
notifyAll():一旦执行此方法，就会唤醒所有被wait的线程。2.说明：
1.wait()，notify()，notifyAll()三个方法必须使用在同步代码块或同步方法中。
2.wait()，notify()，notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器。否则，会出现IllegalMonitorStateException异常
3.wait()，notify()，notifyAll()三个方法是定义在java.lang.Object类中。
②线程通信的实现
1.创建Clerk类，并编写生产和消费产品的方法
2.通过实现Runnable接口类创建生产者消费者线程
3.在run()方法中添加wait()、notify()、notifyAll()方法
/*
* 1.创建Clerk类，并编写生产和消费产品的方法
* 2.通过实现Runnable接口类创建生产者消费者线程
* 3.在run()方法中添加wait()、notify()、notifyAll()方法
*/
class Productor implements Runnable{
private Clerk c;
public Productor(Clerk c) {
this.c=c;
}
@Override
public void run() {
// TODO Auto-generated method stub
while(true) {
synchronized(c) {
c.notify();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
c.createProduct();
}
}
}
}
class Customer implements Runnable{
private Clerk c;
public Customer(Clerk c) {
this.c=c;
}
@Override
public void run() {
// TODO Auto-generated method stub
while(true) {
synchronized(c) {
c.notify();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
c.consumeProduct();
}
}
}
}
class Clerk{
private static int productNum=0;
public int getProductNum() {
return productNum;
}
public void setProductNum(int productNum) {
this.productNum = productNum;
}
public void createProduct() {
if(productNum<20) {
productNum++;
System.out.println(Thread.currentThread().getName()+":生产了第"+productNum+"个产品");
}else {
try {
wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
public void consumeProduct() {
if(productNum>0) {
System.out.println(Thread.currentThread().getName()+":消费了第"+productNum+"个产品");
productNum--;
}else {
try {
wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
public class ThreadCommunicationTest {
public static void main(String[] args) {
Clerk c=new Clerk();
Productor p1=new Productor(c);
Customer c1=new Customer(c);
Thread pt1=new Thread(p1);
Thread ct1=new Thread(c1);
pt1.setName("生产者1号");
ct1.setName("消费者1号");
pt1.start();
ct1.start();
}
}