一、多线程概念

之前学习的程序在没有跳转语句的前提下，都是由上至下依次执行，那现在想要设计一个程序，边打游戏边听歌，怎么设计？

要解决上述问题,就需要使用多进程或者多线程来解决.

1. 并发与并行

并发：指两个或多个事件在同一个时间段内发生。

并行：指两个或多个事件在同一时刻发生（同时发生）。

在操作系统中，安装了多个程序，并发指的是在一段时间内宏观上有多个程序同时运行，这在单 CPU 系统中，每一时刻只能有一道程序执行，即微观上这些程序是分时的交替运行，只不过是给人的感觉是同时运行，那是因为分时交替运行的时间是非常短的。

而在多个 CPU 系统中，则这些可以并发执行的程序便可以分配到多个处理器上（CPU），实现多任务并行执行，即利用每个处理器来处理一个可以并发执行的程序，这样多个程序便可以同时执行。目前电脑市场上说的多核 CPU，便是多核处理器，核越多，并行处理的程序越多，能大大的提高电脑运行的效率。

注意：单核处理器的计算机肯定是不能并行的处理多个任务的，只能是多个任务在单个CPU上并发运行。同理,线程也是一样的，从宏观角度上理解线程是并行运行的，但是从微观角度上分析却是串行运行的，即一个线程一个线程的去运行，当系统只有一个CPU时，线程会以某种顺序执行多个线程，这种情况称之为线程调度。

2. 线程与进程

进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。

线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程

3. 多线程原理

个人简单理解：以前只能顺序运行一个程序，使用多线程可以同时运行多个程序

4. 线程的创建

java.lang.Thread 类，API中该类中定义了有关线程的一些方法，具体如下：

构造方法：

public Thread() :分配一个新的线程对象。

public Thread(String name) :分配一个指定名字的新的线程对象。

public Thread(Runnable target) :分配一个带有指定目标新的线程对象。

public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定名字。

常用方法：

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

public void start() :导致此线程开始执行; Java虚拟机调用此线程的run方法。

public void run() :此线程要执行的任务在此处定义代码。

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

public static Thread currentThread() :返回对当前正在执行的线程对象的引用。

方式一：继承Thread类

// 线程类
// 1.定义线程类 Remix_Thread 继承 Thread 类
class Remix_Thread extends Thread {
    /**
     * 示例：使用继承Thread类的方式创建一个线程，实现输出1-5
     * 2.子类中重写Thread类中的run方法
     */
    @Override
    public void run() {
        for (int i = 1; i < 6; i++) {
            System.out.println(i);
        }
    }
}

// 测试类 Remix_Test
class Remix_Test {
    public static void main(String[] args) {
        // 方式一：继承Thread类
        // 3.创建线程对象
        Remix_Thread rt = new Remix_Thread();
        // 4.调用线程对象的start方法启动线程
        rt.start();
    }
}

方式二：实现Runnable接口

// 1.定义线程实现类 Remix_Runnable类 实现Runnable接口
class Remix_Runnable implements Runnable {
    /**
     * 示例：使用实现Runnable接口的方式创建一个线程，实现从1输出到5。
     * 2.实现类中重写Runnable接口中的run方法
     */
    @Override
    public void run() {
        for (int i = 1; i < 6; i++) {
            System.out.println(i);
        }
    }
}

class Remix_Test {
    public static void main(String[] args) {
        // 方式二：实现Runnable接口
        // 3.创建Runnable接口的子类对象
        Remix_Runnable rr = new Remix_Runnable();
        // 4.通过Thread类创建线程对象
        // 将Runnable接口的子类对象作为参数传递给Thread类的构造方法
        Thread t1 = new Thread(rr);
        // 5.调用Thread类的start方法启动线程
        t1.start();  
    }
}

方式三：通过Callable和Future创建线程

// 1.定义子类Remix_Callable，实现Callable接口，带有返回值；
class Remix_Callable implements Callable<Integer> {
    /**
     * 示例：使用Callable和Future的方式创建一个线程，实现从1输出到5。
     * 2.子类中重写Callable接口中的call方法
     */
    @Override
    public Integer call(){
        Integer num = 0;
        for (int i = 1; i <= 5; i++) {
            System.out.println(i);
            num = i;
        }
        return num;
    }
}

class Remix_Test {
    public static void main(String[] args) {
        // 方式三：过Callable和Future创建线程
        // 3.创建Callable接口的实现类对象
        Remix_Callable rc = new Remix_Callable();
        // 4.使用FutureTask类来包装Callable对象
        FutureTask task = new FutureTask(rc);
        // 5.通过Thread类的构造器创建线程对象
        // 使用FutureTask象作为Thread对象的 target创建
        // 6.创建Thread对象并调用start方法启动线程
        new Thread(task).start();
        // 输出线程执行后的返回值
        try {
            // 7.调用FutureTask对象的get方法来获得线程执行结束后的返回值；
            System.out.println(task.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

5. Thread和Runnable的区别

如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。

总结： 实现Runnable接口比继承Thread类所具有的优势：

1. 适合多个相同的程序代码的线程去共享同一个资源。
2. 可以避免java中的单继承的局限性。
3. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
4. 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。

二、线程安全

如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全

1. 线程同步

当使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。 为了保证每个线程都能正常执行原子操作,Java引入了线程同步机制。

有三种方式完成同步操作：

1. 同步代码块。
2. 同步方法。
3. 锁机制（Lock锁）

2. 同步代码块

同步代码块： synchronized 关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。

// 格式：
synchronized(同步锁){ 
    // 需要同步操作的代码
}

同步锁: 对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁.

1. 锁对象 可以是任意类型。
2. 多个线程对象 要使用同一把锁。

注意：在任何时候,最多允许一个线程拥有同步锁,谁拿到锁就进入代码块,其他的线程只能在外等着 (BLOCKED)。

3. 同步方法

同步方法:使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。

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

同步锁是谁?

对于非static方法,同步锁就是this。

对于static方法,可以使用当前方法所在类的字节码对象(类名.class)。

4. Lock锁

java.util.concurrent.locks.Lock 机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作,同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。

Lock锁也称同步锁，加锁与释放锁方法化了，如下：

public void lock() :加同步锁。

public void unlock() :释放同步锁。

三、线程状态

在API中 java.lang.Thread.State 这个枚举中给出了六种线程状态：

线程状态	导致状态发生条件
NEW(新建)	线程刚被创建，但是并未启动。还没调用start方法。
Runnable(可运行)	线程可以在java虚拟机中运行的状态，可能正在运行自己代码，也可能没有，这取决于操作系统处理器。
Blocked(锁阻塞)	当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。
Waiting(无限等待)	一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。
TimedWaiting(计时等待)	同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep 、Object.wait。
Teminated(被终止)	因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。

补充：线程的生命周期

四、线程的常用操作方法

1. 设置和获取线程名称

获取当前线程名称的代码： Thread.currentThread().getName(); 可以通过Thread类的构造方法或者setName方法设置线程名称

2. 线程的休眠

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

3. 线程的强制运行

void join() :等待该线程终止。

调用Thread类中的jojn方法可以让一个线程独占CPU资源，直到它完成线程的所有操作，CPU资源才会分配给其他线程执行。

4. 线程的暂停

static void yield() : 暂停当前正在执行的线程对象，并执行其他线程。

yield方法可以是线程暂时让出CPU，但是也有可能继续被CPU调度而接着执行。

yield方法和sleep方法的区别：

1. sleep方法使当前线程暂停指定的时间
2. yield方法使运行状态的线程进入就绪状态

5. 后台线程

在Java程序中有两类线程，分别是用户线程（前台线程）、守护线程（后台线程）。

void setDaemon(boolean on) ：将该线程标记为守护线程或用户线程。

boolean isDaemon() ：测试该线程是否为守护线程。

将线程设置为后台线程后，当所有非后台线程执行完毕时，后台线程也会停止执行。main线程是非后台线程。否则JVM虚拟机不会退出。

6. 线程的优先级

Java程序中有最高、中等、最低3种优先级，当所有的线程在运行前都会保持在就绪状态，会先执行优先级高的线程。

int getPriority() ：返回线程的优先级。

void setPriority(int newPriority) ：更改线程的优先级。

优先级	描述	表示常量
MIN_PRIORITY	最低优先级	1
NORM_PRIORITY	中等优先级，默认优先级	5
MAX_PRIORITY	最高优先级	10

7. 线程的中断

void interrupt()：中断线程。

static boolean interrupted()：测试当前线程是否已经中断。

boolean isInterrupted()： 测试线程是否已经中断。

线程的中断其实是为了优雅的停止线程的运行，为了不使用stop方法而设置的。因为JDK不推荐使用stop方法进行线程的停止，stop方法会释放锁并强制终止线程，会造成执行一半的线程终止，带来数据的不一致性。

五、线程的等待唤醒机制

1. 线程间通信

概念：多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同。

为什么要处理线程间通信：

多个线程并发执行时, 在默认情况下CPU是随机切换线程的，当需要多个线程来共同完成一件任务，并且希望多个线程有规律的执行, 那么多线程之间需要一些协调通信，以此来达到多线程共同操作一份数据。

如何保证线程间通信有效利用资源：

多个线程在处理同一个资源，并且任务不同时，需要线程通信来帮助解决线程之间对同一个变量的使用或操作。就是多个线程在操作同一份数据时，避免对同一共享变量的争夺。也就是需要通过一定的手段使各个线程能有效的利用资源。而这种手段即 —— 等待唤醒机制

2. 等待唤醒机制

什么是等待唤醒机制？

这是多个线程间的一种协作机制。谈到线程便会经常想到的是线程间的竞争（race），比如去争夺锁，但这并不是故事的全部，线程间也会有协作机制。就是在一个线程进行了规定操作后，就进入等待状态（wait()）， 等待其他线程执行完指定代码过后 再将其唤醒（notify()）;

在有多个线程进行等待时， 如果需要，可以使用 notifyAll()来唤醒所有的等待线程。wait/notify 就是线程间的一种协作机制。

等待唤醒中的方法 等待唤醒机制就是用于解决线程间通信的问题的，使用到的3个方法的含义如下：

1. wait：线程不再活动，不再参与调度，进入 wait set 中，因此不会浪费 CPU 资源，也不会去竞争锁了，这时的线程状态即是 WAITING。它还要等着别的线程执行一个特别的动作，也即是“通知（notify）”在这个对象上等待的线程从wait set 中释放出来，重新进入到调度队列（ready queue）中
2. notify：则选取所通知对象的 wait set 中的一个线程释放；
3. notifyAll：则释放所通知对象的 wait set 上的全部线程。

注意：哪怕只通知了一个等待的线程，被通知线程也不能立即恢复执行，因为它当初中断的地方是在同步块内，而此刻它已经不持有锁，所以它需要再次尝试去获取锁（很可能面临其它线程的竞争），成功后才能在当初调 用 wait 方法之后的地方恢复执行。

总结如下：

如果能获取锁，线程就从 WAITING 状态变成 RUNNABLE 状态； 否则，从 wait set 出来，又进入 entry set，线程就从 WAITING 状态又变成 BLOCKED 状态

调用wait和notify方法需要注意的细节

1. wait方法与notify方法必须要由同一个锁对象调用。因为：对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。
2. wait方法与notify方法是属于Object类的方法的。因为：锁对象可以是任意对象，而任意对象的所属类都是继承了Object类的。
3. wait方法与notify方法必须要在同步代码块或者是同步函数中使用。因为：必须要通过锁对象调用这2个方法。

六、线程池

1. 线程池概念

线程池：其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。

合理利用线程池能够带来三个好处：

1. 降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
2. 提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
3. 提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。

2. 线程池的使用

Java里面线程池的顶级接口是 java.util.concurrent.Executor ，但是严格意义上讲 Executor 并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是 java.util.concurrent.ExecutorService 。

要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，很有可能配置的线程池不是较优的，因此在 java.util.concurrent.Executors 线程工厂类里面提供了一些静态工厂，生成一些常用的线程池。官方建议使用Executors工程类来创建线程池对象。

public static ExecutorService newFixedThreadPool(int nThreads) ：返回线程池对象。(创建的是有界线程池,也就是池中的线程个数可以指定最大数量)

public Future<?> submit(Runnable task) :获取线程池中的某一个线程对象，并执行

Future接口：用来记录线程任务执行完毕后产生的结果。线程池创建与使用。

使用线程池中线程对象的步骤：

1. 创建线程池对象。
2. 创建Runnable接口子类对象。
3. 提交Runnable接口子类对象。
4. 关闭线程池(一般不做)。