一.基本概念：程序程序、进程、线程
- 程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。
- 进程(process)是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期
- 线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径
-
- 线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小 若一个进程同一时间并行执行多个线程，就是支持多线程的。
补充：何时需要多线程？
- 程序需要同时执行两个或多个任务。
- 程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。
- 需要一些后台运行的程序时。
二.线程的创建和使用
Java中的的JVM允许程序运行多个线程，它通过java.lang.Thread 类来体现。
1. Thread的特性：
- 每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体
- 通过该Thread对象的start()方法来启动这个线程，而非直接调用run()
2. Thread类的构造方法
| 标题 | |
|---|---|
| Thread() | 创建新的Thread对象 |
| Thread(String threadname) | 创建线程并指定线程实例名 |
| Thread(Runnable target) | 指定创建线程的目标对象，它实现了Runnable接口中的run方法 |
| Thread(Runnable target, String name) | 创建新的Thread对象 |
3.创建线程的两种方式
方式一：继承Thread类
定义子类继承Thread类。
子类中重写Thread类中的run方法。
创建Thread子类对象，即创建了线程对象。
调用线程对象start方法：启动线程，调用run方法。
例：
public class MyThread extends Thread {
public MyThread(){
super();
}
public void run(){
System.out.println("线程已启动");
}
}
public class TestThread {
public static void main(String[] args) {
// 创建线程
MyThread mt=new MyThread();
// 启动线程；并调用run（）方法
mt.start();
}
}
方式二：方式二：实现Runnable接口
定义子类，实现Runnable接口
子类中重写Runnable接口中的run方法。
通过Thread类含参构造器创建线程对象。
将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中。
调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法
例：
//1. 创建一个实现了Runnable接口的类
public class MyThread2 implements Runnable {
//2. 实现类去实现Runnable中的抽象方法：run()
@Override
public void run() {
System.out.println("线程启动了");
}
}
public class TestThread2 {
public static void main(String[] args) {
//3. 创建实现类的对象
MyThread2 mThread = new MyThread2();
//4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
Thread t1 = new Thread(mThread);
t1.setName("线程1");
//5. 通过Thread类的对象调用start():① 启动线程 ②调用当前线程的run()-->调用了Runnable类型的target的run()
t1.start();
}
}
注意：如果自己手动调用run()方法，那么就只是普通方法，没有启动多线程模式。想要启动多线程，必须调用start（）方法。并且一个线程对象只能调用一次start()方法启动，如果重复调用了，则将抛出异常“IllegalThreadStateException”。
两种方式的区别与联系：
区别：
- -继承Thread：线程代码存放Thread子类run方法中。
- 实现Runnable：线程代码存在接口的子类的run方法。
实现方法的好处：
- 避免了单继承的局限性
- 多个线程可以共享同一个接口实现类的对象，非常适合多个相同线 程来处理同一份资源。
三.线程的生命周期
要想实现多线程，必须在主线程中创建新的线程对象。Java语言使用Thread类 及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五 种状态：
- 新建： 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新状态
- 就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源
- 运行：当就绪的线程被调度并获得CPU资源时,便进入运行状态， run()方法定义了线程的操作和功能
- 阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态
- 死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束
四。线程的同步
在使用多线程时，当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有 执行完，另一个线程参与进来执行。导致共享数据的错误。
解决办法：对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以 参与执行
1.Synchronized
Java对于多线程的安全问题提供了专业的解决方式：同步机制
同步代码块：
synchronized (对象){
// 需要被同步的代码；
} synchronized还可以放在方法声明中，表示整个方法为同步方法。例如： public synchronized void show (String name){
….
}
2.同步机制中的锁
同步锁机制： 在《Thinking in Java》中，是这么说的：对于并发工作，你需要某种方式来防 止两个任务访问相同的资源（其实就是共享资源竞争）。 防止这种冲突的方法 就是当资源被一个任务使用时，在其上加锁。第一个访问某项资源的任务必须 锁定这项资源，使其他任务在其被解锁之前，就无法访问它了，而在其被解锁 之时，另一个任务就可以锁定并使用它了。
注意：
- 必须确保使用同一个资源的多个线程共用一把锁，这个非常重要，否则就无法保证共享资源的安全
- 一个线程类中的所有静态方法共用同一把锁（类名.class），所有非静态方法共用同一把锁（this），同步代码块（指定需谨慎）
3.释放锁的操作和不释放锁的操作
释放锁的操作：
- 当前线程的同步方法、同步代码块执行结束。
- 当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、该方法的继续执行。
- 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束。
- 当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁
不会释放锁的操作：
- 线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行
- 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁（同步监视器）。
4.lock显式锁
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的 工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象 加锁，线程开始访问共享资源之前应先获得Lock对象。而ReentrantLock 类则实现了 Lock ，它拥有synchronized 相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以 显式加锁、释放锁。
class A{
private final ReentrantLock lock = new ReenTrantLock();
public void m(){
lock.lock();
try{
//保证线程安全的代码;
}
finally{
lock.unlock();
}
}
}
synchronized 与 Lock 的对比：
- Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized是隐式锁，出了作用域自动释放
- Lock只有代码块锁，synchronized有代码块锁和方法锁
- 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）
