Java多线程基础

程序、进程、线程的概念

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

进程（process）：程序的一次执行过程，或是正在内存中运行的应用程序。如：运行中的QQ，运行中的音乐播放器。

• 每个进程都有一个独立的内存空间，系统运行一个程序即是一个进程从创建、运行到消亡的过程。（生命周期）
• 程序是静态的，进程是动态的。
• 进程作为操作系统调度和分配资源的最小单位（亦是系统运行程序的基本单位），系统在运行时会为每个进程分配不同的内存区域。
• 现代操作系统，大都是支持多进程的，支持同时运行多个程序。

线程（thread）：进程可进一步细化为线程，是程序内部的一条执行路径。一个进程中至少有一个线程。
一个进程同一时间若并行执行多个线程，就是支持多线程的。
线程作为CPU调度和执行的最小单位。
一个进程中的多个线程共享相同的内存单元，它们从同一个堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全隐患。

注意：
不同进程之间是不共享内存的。
进程之间的数据交换和通信的成本很高。

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

并行与并发

并行（parallel）：指两个或多个事件在同一时刻发生（同时发生）。指在同一时刻，有多条指令在多个CPU上同时执行。比如：多个人同时做不同的事。
并发（concurrency）：指两个或多个事件在同一个时间段内发生。即在一段时间内，有多条指令在单个CPU上快速轮换、交替执行，使得在宏观上具有多个进程同时执行的效果。

操作系统中，启动了多个程序，并发指的是在一段时间内宏观上有多个程序同时运行，在单核 CPU 系统中，每一时刻只能有一个程序执行，即微观上这些程序是分时的交替运行，只是给人的感觉是同时运行，那是因为分时交替运行的时间是非常短的。而在多核 CPU 系统中，这些可以并发执行的程序便可以分配到多个CPU上，实现多任务并行执行，即利用每个处理器来处理一个可以并发执行的程序，这样多个程序便可以同时执行。目前电脑市场上说的多核 CPU，便是多核处理器，核越多，并行处理的程序越多，能大大的提高电脑运行的效率。

线程的创建方式

Java语言的JVM允许程序运行多个线程，使用java.lang.Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。
Thread类的特性

• 每个线程都是通过某个特定Thread对象的run()方法来完成操作的，因此把run()方法体称为线程执行体。
• 通过该Thread对象的start()方法来启动这个线程，而非直接调用run()
• 要想实现多线程，必须在主线程中创建新的线程对象。

方式1：继承Thread类
1、创建一个继承于Thread类的子类
2、重写Thread类的run() —>将此线程要执行的操作声明在此方法体中
3、创建当前Thread的子类对象
4、通过对象调用start()：1、启动线程 2、调用当前线程的run()

能否使用t1.run()替换t1.start()的调用,实现分线程的创建和调用？ 不能！

注意：

1. 如果自己手动调用run()方法，那么就只是普通方法，没有启动多线程模式。
2. run()方法由JVM调用，什么时候调用，执行的过程控制都有操作系统的CPU调度决定。
3. 想要启动多线程，必须调用start方法。
4. 一个线程对象只能调用一次start()方法启动，如果重复调用了，则将抛出以上的异常“IllegalThreadStateException”。

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

public class NumberPrintTest {
    public static void main(String[] args) {
        //方式1
        EvenNumberPrint t1 = new EvenNumberPrint();
        t1.start();

        OddNumberPrint t2 = new OddNumberPrint();
        t2.start();

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

        //方式2：创建Thread类的匿名子类的匿名对象
        new Thread(){
            @Override
            public void run() {
                for (int i = 1; i <= 100; i++) {
                    if (i % 2 == 0) {
                        System.out.println(Thread.currentThread().getName() + ":" + i);
                    }
                }
            }
        }.start();

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

方式2：实现Runnable接口
1、创建一个实现Runnable接口的类
2、实现接口中的run() —>将此线程要执行的操作声明在此方法体中
3、创建当前实现类的对象
4、将此对象作为参数传递到Thread类的构造器中，创建Thread类实例。
5、Thread类的实例调用start()：1、启动线程 2、调用当前线程的run()

public class EvenNumberPrint implements Runnable{

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

public class NumberPrintTest {
    public static void main(String[] args) {
        //接口实现方式1
        EvenNumberPrint p1 = new EvenNumberPrint();
        Thread t1 = new Thread(p1);
        // 创建同一任务的第二个线程
        Thread t2 = new Thread(p1);
        t1.start();
        t2.start();

        //接口实现方式2：提供Runnable接口匿名实现类的匿名对象
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 100; i++) {
                    if (i % 2 == 0) {
    					System.out.println(Thread.currentThread().getName() + ":" + i);
                    }
                }
            }
        }).start();
    }
}

对比两种方式：
共同点：
1、启动线程，使用的都是Thread类中定义的start()
2、创建的线程对象都是Thread类或其子类的实例

不同点：一个是类的继承，一个是接口的实现，建议使用Runnable接口的方式
Runnable方式的好处：1、实现的方式避免了类的单继承局限性。
2、更适合处理有共享数据的问题。 3、实现了代码和数据的分离。

联系：publicclass Thread implements Runnable（代理模式）

Thread类的常用方法和生命周期

Thread构造器

• public Thread() :分配一个新的线程对象。
• public Thread(String name) :分配一个指定名字的新的线程对象。
• public Thread(Runnable target) :指定创建线程的目标对象，它实现了Runnable接口中的run方法。
• public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定名字。

线程中的常用方法

• run() :声明此线程要执行的任务，在此处定义代码。

• start() :启动线程，调用线程的run(）

• currentThread()：获取当前执行代码对应的线程对象的引用。

• getName() :获取当前线程名称。

• setName(String name)：设置该线程名称。

• public static void sleep(long millis) :使当前正在执行的线程以指定毫秒数暂停（暂停执行）。

• public static void yield()：yield只是让当前线程暂停一下，释放CPU的执行权，让系统的线程调度器重新调度一次，希望优先级与当前线程相同或更高的其他线程能够获得执行机会，但是这个不能保证，完全有可能的情况是，当某个线程调用了yield方法暂停之后，线程调度器又将其调度出来重新执行。

• public final void join() throws InterruptedException：在线程a中通过线程b的对象调用join()，意味着线程a进入阻塞状态，直到线程b执行结束，线程a才结束阻塞状态继续执行。

• public final boolean isAlive()：测试线程是否处于存活状态。如果线程已经启动且尚未终止，则为存活状态。

• public final void stop()：已过时，不建议使用。强行结束一个线程的执行，直接进入死亡状态。run()即刻停止，可能会导致一些清理性的工作得不到完成，如文件，数据库等的关闭。同时，会立即释放该线程所持有的所有的锁，导致数据得不到同步的处理，出现数据不一致的问题。

• void suspend() / void resume() : 这两个操作就好比播放器的暂停和恢复。二者必须成对出现，否则非常容易发生死锁。suspend()调用会导致线程暂停，但不会释放任何锁资源，导致其它线程都无法访问被它占用的锁，直到调用resume()。已过时，不建议使用。

线程优先级
每个线程都有一定的优先级，同优先级线程组成先进先出队列（先到先服务），使用分时调度策略。优先级高的线程采用抢占式策略，获得较多的执行机会。每个线程默认的优先级都与创建它的父线程具有相同的优先级。

• Thread类的三个优先级常量：
  • MAX_PRIORITY（10）：最高优先级
  • MIN _PRIORITY （1）：最低优先级
  • NORM_PRIORITY （5）：普通优先级，默认情况下main线程具有普通优先级。

• public final int getPriority() ：返回线程优先级
• public final void setPriority(int newPriority) ：改变线程的优先级，范围在[1,10]之间。

守护线程（了解）
有一种线程，在后台运行，它的任务是为其他线程提供服务，这种线程被称为“守护线程”。JVM的垃圾回收线程就是典型的守护线程。
守护线程有个特点，就是如果所有非守护线程都死亡，那么守护线程自动死亡。形象理解：兔死狗烹，鸟尽弓藏
调用setDaemon(true)方法可将指定线程设置为守护线程。
必须在线程启动之前设置，否则会报IllegalThreadStateException异常。
调用isDaemon()可以判断线程是否是守护线程。

线程的生命周期

JDK5之前的线程的生命周期 5种状态
线程的生命周期有五种状态：新建（New）、就绪（Runnable）、运行（Running）、阻塞（Blocked）、死亡（Dead）。CPU需要在多条线程之间切换，于是线程状态会多次在运行、阻塞、就绪之间切换。
1.新建
当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态。此时它和其他Java对象一样，仅仅由JVM为其分配了内存，并初始化了实例变量的值。此时的线程对象并没有任何线程的动态特征，程序也不会执行它的线程体run()。

2.就绪
但是当线程对象调用了start()方法后，就不一样了，线程就从新建状态转为就绪状态。JVM会为其创建方法调用栈和程序计数器，当然，处于这个状态中的线程并没有开始运行，只是表示已具备了运行的条件，随时可以被调度。至于什么时候被调度，取决于JVM里线程调度器的调度。

注意：
程序只能对新建状态的线程调用start()，并且只能调用一次，如果对非新建状态的线程，如已启动的线程或已死亡的线程调用start()都会报错IllegalThreadStateException异常。

3.运行

如果处于就绪状态的线程获得了CPU资源时，开始执行run()方法的线程体代码，则该线程处于运行状态。如果计算机只有一个CPU核心，在任何时刻只有一个线程处于运行状态，如果计算机有多个核心，将会有多个线程并行(Parallel)执行。

当然，美好的时光总是短暂的，而且CPU讲究雨露均沾。对于抢占式策略的系统而言，系统会给每个可执行的线程一个小时间段来处理任务，当该时间用完，系统会剥夺该线程所占用的资源，让其回到就绪状态等待下一次被调度。此时其他线程将获得执行机会，而在选择下一个线程时，系统会适当考虑线程的优先级。

4.阻塞

当在运行过程中的线程遇到如下情况时，会让出 CPU 并临时中止自己的执行，进入阻塞状态：

• 线程调用了sleep()方法，主动放弃所占用的CPU资源；
• 线程试图获取一个同步监视器，但该同步监视器正被其他线程持有；
• 线程执行过程中，同步监视器调用了wait()，让它等待某个通知（notify）；
• 线程执行过程中，同步监视器调用了wait(time)
• 线程执行过程中，遇到了其他线程对象的加塞（join）；
• 线程被调用suspend方法被挂起（已过时，因为容易发生死锁）；

当前正在执行的线程被阻塞后，其他线程就有机会执行了。针对如上情况，当发生如下情况时会解除阻塞，让该线程重新进入就绪状态，等待线程调度器再次调度它：

• 线程的sleep()时间到；
• 线程成功获得了同步监视器；
• 线程等到了通知(notify)；
• 线程wait的时间到了
• 加塞的线程结束了；
• 被挂起的线程又被调用了resume恢复方法（已过时，因为容易发生死锁）；

5.死亡

线程会以以下三种方式之一结束，结束后的线程就处于死亡状态：

• run()方法执行完成，线程正常结束
• 线程执行过程中抛出了一个未捕获的异常（Exception）或错误（Error）
• 直接调用该线程的stop()来结束该线程（已过时）
  
  JDK5之后的线程的生命周期 6种状态
  java.lang.Thread.State的枚举类中这样定义：

public enum State {
	NEW,
	RUNNABLE,
	BLOCKED,
	WAITING,
	TIMED_WAITING,
	TERMINATED;
}

• NEW（新建）：线程刚被创建，但是并未启动。还没调用start方法。

• RUNNABLE（可运行）：这里没有区分就绪和运行状态。因为对于Java对象来说，只能标记为可运行，至于什么时候运行，不是JVM来控制了，是OS来进行调度的，而且时间非常短暂，因此对于Java对象的状态来说，无法区分。

• TERMINATED（被终止）：表明此线程已经结束生命周期，终止运行。

• 重点说明，根据Thread.State的定义，阻塞状态分为三种：BLOCKED、WAITING、TIMED_WAITING。

  • BLOCKED（锁阻塞）：在API中的介绍为：一个正在阻塞、等待一个监视器锁（锁对象）的线程处于这一状态。只有获得锁对象的线程才能有执行机会。
    • 比如，线程A与线程B代码中使用同一锁，如果线程A获取到锁，线程A进入到Runnable状态，那么线程B就进入到Blocked锁阻塞状态。
  • TIMED_WAITING（计时等待）：在API中的介绍为：一个正在限时等待另一个线程执行一个（唤醒）动作的线程处于这一状态。
    • 当前线程执行过程中遇到Thread类的sleep或join，Object类的wait，LockSupport类的park方法，并且在调用这些方法时，设置了时间，那么当前线程会进入TIMED_WAITING，直到时间到，或被中断。
  • WAITING（无限等待）：在API中介绍为：一个正在无限期等待另一个线程执行一个特别的（唤醒）动作的线程处于这一状态。
    • 当前线程执行过程中遇到遇到Object类的wait，Thread类的join，LockSupport类的park方法，并且在调用这些方法时，没有指定时间，那么当前线程会进入WAITING状态，直到被唤醒。
      • 通过Object类的wait进入WAITING状态的要有Object的notify/notifyAll唤醒；
      • 通过Condition的await进入WAITING状态的要有Condition的signal方法唤醒；
      • 通过LockSupport类的park方法进入WAITING状态的要有LockSupport类的unpark方法唤醒
      • 通过Thread类的join进入WAITING状态，只有调用join方法的线程对象结束才能让当前线程恢复；

说明：当从WAITING或TIMED_WAITING恢复到Runnable状态时，如果发现当前线程没有得到监视器锁，那么会立刻转入BLOCKED状态。

翻阅API的时候会发现Timed Waiting（计时等待） 与 Waiting（无限等待） 状态联系还是很紧密的，
比如Waiting（无限等待） 状态中wait方法是空参的，而timed waiting（计时等待） 中wait方法是带参的。
这种带参的方法，其实是一种倒计时操作，相当于我们生活中的小闹钟，我们设定好时间，到时通知，可是
如果提前得到（唤醒）通知，那么设定好时间在通知也就显得多此一举了，那么这种设计方案其实是一举两
得。如果没有得到（唤醒）通知，那么线程就处于Timed Waiting状态，直到倒计时完毕自动醒来；如果在倒
计时期间得到（唤醒）通知，那么线程从Timed Waiting状态立刻唤醒。

同一个资源问题和线程的安全问题

当我们使用多个线程访问同一资源（可以是同一个变量、同一个文件、同一条记录等）的时候，若多个线程只有读操作，那么不会发生线程安全问题。但是如果多个线程中对资源有读和写的操作，就容易出现线程安全问题。

多线程卖票出现的问题：出现了重票和错票。
什么原因导致的？ 线程1操作ticket的过程中，尚未结束的情况下，其他线程也参与进来，对ticket进行操作。
如何解决？ 必须保证一个线程a在操作ticket的过程中，其他线程必须等待，直到线程a操作ticket结束以后，其他线程才可以继续操作ticket。
Java如何解决线程安全问题？ 使用线程同步机制
方式1：同步代码块
synchronized(同步监视器){
//需要被同步的代码
}
说明：

需要被同步的代码，即为操作共享数据的代码
共享数据，即多个线程都需要操作的数据，比如ticket
需要被同步的代码，在被synchronized包裹以后，使得一个线程在操作这些代码的过程中，其他线程必须等待。
同步监视器 俗称锁，哪个线程获得了锁，哪个线程就能执行需要被同步的代码
同步监视器可以使用任何一个类的对象充当，但是多个线程必须共用同一个同步监视器。

注意：

在实现Runnable接口的方式中，同步监视器可以考虑使用this
在继承Thread类的方式中，同步监视器要慎用this，可以考虑使用当前类.class

class SaleTicket implements Runnable {
    private int ticket = 100;
    private Object object = new Object();

    @Override
    public void run() {
        while (true) {
            // synchronized (object) {  //需保证监视器唯一
            synchronized (this){
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + ":" + "售出了票号为" + ticket + "的票...");
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

public class SaleTicketTest {
    public static void main(String[] args) {
        SaleTicket sale = new SaleTicket();
        Thread t1 = new Thread(sale);
        Thread t2 = new Thread(sale);
        Thread t3 = new Thread(sale);
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

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

    }
}

class SaleTicket1 extends Thread {
    private static int ticket = 100;
    private static Object object = new Object();

    @Override
    public void run() {
        while (true) {
            // synchronized (object) {  //加static保证object唯一
            synchronized (SaleTicket1.class) {
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + ":" + "售出了票号为" + ticket + "的票...");
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

public class SaleTicketTest1 {
    public static void main(String[] args) {
        SaleTicket1 t1 = new SaleTicket1();
        SaleTicket1 t2 = new SaleTicket1();
        SaleTicket1 t3 = new SaleTicket1();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

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

方式2：同步方法

同步方法： synchronized 关键字直接修饰方法，表示同一时刻只有一个线程能进入这个方法，其他线程在外面等着。

public synchronized void method(){
    //可能会产生线程安全问题的代码
}

如果操作共享数据的代码完整声明在一个方法中，可以将此方法声明为同步方法。
非静态的同步方法，默认同步监视器是this。
静态的同步方法，默认同步监视器的当前类本身。

class WindowTicket implements Runnable {
    private int ticket = 100;
    private boolean flag = true;

    @Override
    public void run() {
        while (flag) {
            sale();
        }
    }

    public synchronized void sale() {  //默认同步监视器为this
        if (ticket > 0) {
            System.out.println(Thread.currentThread().getName() + ":" + "售出了票号为" + ticket + "的票...");
            ticket--;
        } else {
            flag = false;
        }
    }
}

public class WindowTicketTest {
    public static void main(String[] args) {
        WindowTicket ticket = new WindowTicket();
        Thread t1 = new Thread(ticket);
        Thread t2 = new Thread(ticket);
        Thread t3 = new Thread(ticket);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

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

class WindowTicket1 extends Thread {
    private static int ticket = 100;
    private static boolean flag = true;

    @Override
    public void run() {
        while (flag) {
            sale();
        }
    }

    // public synchronized void sale() { //默认同步监视器为this
    public static synchronized void sale() { //此时同步监视器为当前类本身,WindowTick1.class
        if (ticket > 0) {
            System.out.println(Thread.currentThread().getName() + ":" + "售出了票号为" + ticket + "的票...");
            ticket--;
        } else {
            flag = false;
        }
    }
}

public class WindowTicketTest1 {
    public static void main(String[] args) {
        WindowTicket1 t1 = new WindowTicket1();
        WindowTicket1 t2 = new WindowTicket1();
        WindowTicket1 t3 = new WindowTicket1();
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}

synchronized的好处：解决了线程的安全问题。
弊端：在操作共享数据时，多线程变为串行执行，意味着性能较低。

线程安全的懒汉式、死锁 、ReentrantLock的使用

class Bank {
    private static volatile Bank instance = null;

    private Bank() {
    }
    // 实现线程安全的方式1
    // public static synchronized Bank getInstance() {  //同步监视器默认为Bank.class
    //     if (instance == null) {
    //         try {
    //             Thread.sleep(100);
    //         } catch (InterruptedException e) {
    //             e.printStackTrace();
    //         }
    //         instance = new Bank();
    //     }
    //     return instance;
    // }

    // 实现线程安全的方式2
    // public static Bank getInstance() {  //同步监视器默认为Bank.class
    //     synchronized (Bank.class) {
    //         if (instance == null) {
    //             try {
    //                 Thread.sleep(1000);
    //             } catch (InterruptedException e) {
    //                 e.printStackTrace();
    //             }
    //             instance = new Bank();
    //         }
    //     }
    //     return instance;
    // }

    // 实现线程安全的方式3 可能存在指令重排，需要在instance上加volatile关键字，避免指令重排
    public static  Bank getInstance() {  //同步监视器默认为Bank.class
        if (instance == null) {
            synchronized (Bank.class) {
                if (instance == null) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    instance = new Bank();
                }
            }
        }
        return instance;
    }
}

public class BankTest {
    public static Bank bank1 = null;
    public static Bank bank2 = null;

    public static void main(String[] args) {
        Thread t1 = new Thread() {
            @Override
            public void run() {
                bank1 = Bank.getInstance();
            }
        };
        Thread t2 = new Thread() {
            @Override
            public void run() {
                bank2 = Bank.getInstance();
            }
        };
        t1.start();
        t2.start();

        //让t1,t2线程先执行完，再执行主线程
        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(bank1);
        System.out.println(bank2);
        System.out.println(bank1 == bank2);
    }
}

死锁
不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。
一旦出现死锁，整个程序既不会发生异常，也不会给出任何提示，只是所有线程处于阻塞状态，无法继续。

死锁演示：

public class DeadLockTest {
    public static void main(String[] args) {
        StringBuilder s1 = new StringBuilder();
        StringBuilder s2 = new StringBuilder();

        new Thread() {
            @Override
            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");
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }.start();

        new Thread() {
            @Override
            public void run() {
                synchronized (s2) {
                    s1.append("c");
                    s2.append("3");
                    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();
    }
}

诱发死锁的原因：

• 互斥条件
• 占用且等待
• 不可抢夺（或不可抢占）
• 循环等待
  以上4个条件，同时出现就会触发死锁。

解决死锁：
死锁一旦出现，基本很难人为干预，只能尽量规避。可以考虑打破上面的诱发条件。
针对条件1：互斥条件基本上无法被破坏。因为线程需要通过互斥解决安全问题。
针对条件2：可以考虑一次性申请所有所需的资源，这样就不存在等待的问题。
针对条件3：占用部分资源的线程在进一步申请其他资源时，如果申请不到，就主动释放掉已经占用的资源。
针对条件4：可以将资源改为线性顺序。申请资源时，先申请序号较小的，这样避免循环等待问题。

JDK5.0新特性：Lock(锁)

• JDK5.0的新增功能，保证线程的安全。与采用synchronized相比，Lock可提供多种锁方案，更灵活、更强大。Lock通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
• java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
• 在实现线程安全的控制中，常用ReentrantLock（可重入锁），可以显式加锁、释放锁。
  • ReentrantLock类实现了 Lock 接口，它拥有与 synchronized 相同的并发性和内存语义，但是添加了类似锁投票、定时锁等候和可中断锁等候的一些特性。此外，它还提供了在激烈争用情况下更佳的性能。
• Lock锁也称同步锁，加锁与释放锁方法，如下：
  • public void lock() :加同步锁。
  • public void unlock() :释放同步锁。

可重入锁实例：

import java.util.concurrent.locks.ReentrantLock;

class Window extends Thread {

    private static int ticket = 100;
    private static boolean flag = true;
    //创建Lock的实例，需要确保多个线程共用同一个Lock实例，考虑声明对象为static final
    private static final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (flag) {
            try {
                //执行lock()方法,锁定对共享资源的调用
                lock.lock();
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + ":" + "售出了票号为" + ticket + "的票...");
                    ticket--;
                } else {
                    flag = false;
                }
            } finally {
                //finally保证对unlock()的调用，释放对共享数据的锁定
                lock.unlock();
            }
        }
    }
}

public class LockTest {
    public static void main(String[] args) {
        Window t1 = new Window();
        Window t2 = new Window();
        Window t3 = new Window();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}

synchronized和Lock的对比：
synchronized不管是同步代码块还是同步方法，都需要在结束一对{}之后，释放对同步监视器的调用。
Lock是通过两个方法 控制需要被同步的代码，更灵活一些。
Lock作为接口，提供了多种实现类，适合更多、更复杂的场景，效率更高。
Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized是隐式锁，出了作用域、遇到异常等自动解锁。
Lock只有代码块锁，synchronized有代码块锁和方法锁。
使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类），更体现面向对象。
（了解）Lock锁可以对读不加锁，对写加锁，synchronized不可以
（了解）Lock锁可以有多种获取锁的方式，可以从sleep的线程中抢到锁，synchronized不可以

线程间的通信机制

为什么要处理线程间通信：
当我们需要多个线程来共同完成一件任务，并且希望它们有规律的执行，那么多线程之间需要一些通信机制，可以协调它们的工作，以此实现多线程共同操作一份数据。

比如：线程A用来生产包子的，线程B用来吃包子的，包子可以理解为同一资源，线程A与线程B处理的动作，一个是生产，一个是消费，此时B线程必须等到A线程完成后才能执行，那么线程A与线程B之间就需要线程通信，即—— 等待唤醒机制。

等待唤醒机制
多个线程间的一种协作机制。谈到线程我们经常想到的是线程间的竞争（race），比如去争夺锁，但这并不是故事的全部，线程间也会有协作机制。
在一个线程满足某个条件时，就进入等待状态（wait() / wait(time)）， 等待其他线程执行完他们的指定代码过后再将其唤醒（notify()）;或可以指定wait的时间，等时间到了自动唤醒；在有多个线程进行等待时，如果需要，可以使用 notifyAll()来唤醒所有的等待线程。wait/notify 就是线程间的一种协作机制。

wait()：线程不再活动，不再参与调度，进入 wait set 中，因此不会浪费 CPU 资源，也不会去竞争锁，这时的线程状态是 WAITING 或 TIMED_WAITING。它还要等着别的线程执行一个特别的动作，也即“通知（notify）”或者等待时间到，在这个对象上等待的线程从wait set 中释放出来，重新进入到调度队列（ready queue）中
notify()：唤醒wait()的线程中优先级最高的那个线程。优先级相同则随机唤醒一个。被唤醒的线程从当初被wait()的位置继续执行。
notifyAll()：唤醒所有被wait()的线程。

注意：

此三个方法的使用，必须是在同步代码块或同步方法中。
Lock需要配合Condition实现线程间的通信。
此三个方法的调用者，必须是同步监视器的对象，否则报异常IllegalMonitorStateException。
此三个方法声明在Object类中。

wait()和sleep()的对比：
相同点：一旦执行，当前线程都会进入阻塞状态。

不同点：
声明的位置：wait()：声明在Object类中，sleep()：声明在Thread类中，静态的。
使用的场景不同：wait()：只能使用在同步代码块和同步方法中。
sleep()：可以在任何需要使用的地方。
使用在同步代码块或同步方法中，wait()一旦执行，会释放同步监视器。
sleep()一旦执行不会释放同步监视器。
结束阻塞的方式：wait()：到达指定时间自动结束阻塞或通过notify唤醒，结束阻塞。
sleep()：到达指定时间自动结束阻塞。

生产者消费者问题

/**
 * 生产者消费者问题，生产者将产品交给店员，而消费者从店员处取走商品，店员一次只能持有
 * 固定数量的商品(<=20)，如果生产者试图生产更多的产品，店员会叫生产者停下来，如果店内有空位
 * 放产品后再通知生产者继续生产，如果店内没有产品了，店员会告诉消费者等一等，有产品后再通知消费者取走产品。
 */
class Clerk {
    private int productAmount = 0;

    public synchronized void addProduct() {
        if (productAmount < 20) {
            productAmount++;
            System.out.println(Thread.currentThread().getName()+
                    "生产了第"+productAmount+"个产品");
            this.notifyAll();
        }else {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public synchronized void minusProduct() {
        if (productAmount >= 1) {
            System.out.println(Thread.currentThread().getName()+
                    "消费了第"+productAmount+"个产品");
            productAmount--;
            this.notifyAll();
        } else {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Producer extends Thread {
    private Clerk clerk;

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

    @Override
    public void run() {
        System.out.println("生产者开始生产产品...");
        while (true) {
            clerk.addProduct();
            try {
                Thread.sleep(40);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Customer extends Thread {
    private Clerk clerk;

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

    @Override
    public void run() {
        System.out.println("消费者开始消费产品...");
        while (true) {
            clerk.minusProduct();
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class ProducerCustomerTest {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();
        Producer producer1 = new Producer(clerk);
        Customer customer1 = new Customer(clerk);
        Customer customer2 = new Customer(clerk);
        producer1.setName("生产者1");
        customer1.setName("消费者1");
        customer2.setName("消费者2");

        producer1.start();
        customer1.start();
        customer2.start();
        
    }
}

创建线程的新方式Callable和线程池

创建线程的方式3：实现Callable接口（JDK5新增）
与之前的方式对比，与Runnable方式对比的好处：

call()可以有返回值，更加灵活
call()可以使用throws方式处理异常，更加灵活
Callable使用了泛型，可以指明具体的call()的返回值类型，更灵活
缺点：若在主线程中需要获取分线程的返回值，则主线程会被阻塞。

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

/**
 * 打印1-100内的偶数并返回结果
 */
//1.创建一个实现Callable的实现类
class PrintNumber implements Callable {

    //2.实现call方法，将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}

public class CallableTest {
    public static void main(String[] args) {
        //3.创建Callable接口实现类的对象
        PrintNumber print = new PrintNumber();
        //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(print);
        //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        Thread t1 = new Thread(futureTask);
        t1.start();
        System.out.println("main()线程开始执行..");

        //接收返回值
        //6.获取Callable中call方法的返回值
        try {
            Object sum = futureTask.get();
            System.out.println("1-100的偶数总和为" + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

创建线程的方式4：线程池
现有问题：
如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。
有没有一种办法使线程可以复用，即执行完一个任务，并不被销毁，而可以继续执行其他的任务？

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

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

线程池相关API

• JDK5.0之前，必须手动自定义线程池。从JDK5.0开始，Java内置线程池相关的API。
• 在java.util.concurrent包下提供了线程池相关API：ExecutorService 和 Executors。
• ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
  • void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行Runnable
  • <T> Future<T> submit(Callable<T> task)：执行任务，有返回值，一般用来执行Callable
  • void shutdown() ：关闭连接池
• Executors：一个线程池的工厂类，通过此类的静态工厂方法可以创建多种类型的线程池对象。
  • Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
  • Executors.newFixedThreadPool(int nThreads); 创建一个可重用固定线程数的线程池
  • Executors.newSingleThreadExecutor() ：创建一个只有一个线程的线程池
  • Executors.newScheduledThreadPool(int corePoolSize)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。

import java.util.concurrent.*;

class NumberThread implements Runnable {

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

class NumberThread1 implements Runnable {

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

class NumberThread2 implements Callable {

    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
                sum += i;
            }
        }
        return sum;
    }
}

public class ThreadPoolTest {
    public static void main(String[] args) {
        //1. 提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor executor = (ThreadPoolExecutor) service;
        //设置线程池的属性
        System.out.println(service.getClass());
        executor.setMaximumPoolSize(50);//设置线程池中线程数的上限
        //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());  //适用于Runnable
        service.execute(new NumberThread1());


        try {
            Future future = service.submit(new NumberThread2());//适合使用于Callable
            System.out.println(future.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        //3.关闭连接池
        service.shutdown();
    }
}

Q1：stop()和suspend()方法为什么不推荐使用？
stop()：一旦执行，线程就结束了，导致run()有未执行结束的代码，stop()会导致释放同步监视器，导致线程安全问题。
suspend()：与resume()搭配使用，导致死锁。

Q2：当一个线程进入一个对象的一个synchronized方法后，其他线程是否可以进入此对象的其他方法？
需要看其他对象的方法是否用synchronized修饰，同步监视器的this是否是同一个对象。
只有当使用了synchronized，且this是同一个对象的情况下，就不能进入了。

Q3：线程同步和阻塞的关系，同步一定阻塞吗？阻塞一定同步吗？
同步一定阻塞，阻塞不一定同步。

Q4：为什么wait()和notify()方法要在同步块中调用？
因为调用者必须是同步监视器。