线程：线程是程序中的一个执行流，每个线程都有自己的专有寄存器(栈指针、程序计数器等)，但代码区是共享的，即不同的线程可以执行同样的函数。 牛客：多线程：多线程是指程序中包含多个执行流，即在一个程序中可以同时运行多个不同的线程来执行不同的任务，也就是说允许单个程序创建多个并行执行的线程来完成各自的任务
**并行：**多个CPU同时执行多个任务。比如：多个人同时做不同的事。 **并发：**一个CPU(采用时间片)同时执行多个任务。比如：秒杀、多个人做同一件事。 使用多线程的优点： 提高应用程序的响应。对图形化界面更有意义，可增强用户体验 提高计算机系统CPU的利用率 线程，独立运行，利于理解和修改 何时需要多线程 程序需要同时执行两个或多个任务。 程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。 需要一些后台运行的程序时。
程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一 段静态的代码，静态对象。 进程(process)是程序的一次执行过程，或是正在运行的一个程序。是一个动态 的过程：有它自身的产生、存在和消亡的过程。——生命周期 如：运行中的QQ，运行中的MP3播放器 程序是静态的，进程是动态的 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域 线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。 若一个进程同一时间并行执行多个线程，就是支持多线程的 线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数0器(pc)，线程切换的开销小 一个进程中的多个线程共享相同的内存单元/内存地址空间它们从同一堆中分配对象，可以 访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。
4 种 线程创建方式一 继承Thread类创建一个继承于Thread类的子类 重写Thread类的run() --> 将此线程执行的操作声明在run()中 创建Thread类的子类的对象 通过此对象调用start(）
创建两个分线程，让其中一个线程输出1-100之间的偶数，另一个线程输出1-100之间的奇数。 public class MyThread1 extends Thread{ @Override public void run() { for (int i = 1; i <= 100; i++) { if (i%2==0){ System.out.println("线程1输出偶数："+i); } } } } public class MyThread2 extends Thread { @Override public void run() { for (int i = 1; i <= 100; i++) { if (i%2!=0){ System.out.println("线程2输出奇数："+i); } } } } public class TestThread { public static void main(String[] args) { MyThread1 myThread1=new MyThread1(); MyThread2 myThread2=new MyThread2(); myThread1.start(); myThread2.start(); } }线程创建方式二 实现Runnable接口 创建一个实现了Runnable接口的类 实现类去实现Runnable中的抽象方法：run() 创建实现类的对象 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象 通过Thread类的对象调用start()
public class RunableThread implements Runnable { @Override public void run() { System.out.println(Thread.currentThread().getName()); } } public class ThredTest02 { public static void main(String[] args) { RunableThread runableThread=new RunableThread(); new Thread(runableThread).start(); } }两种简便的使用 创建线程的方式三：实现Callable接口。 — JDK 5.0新增 如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？
call()可以有返回值的。call()可以抛出异常，被外面的操作捕获，获取异常的信息Callable是支持泛型的 步骤： 1.创建一个实现Callable的实现类 2.实现call方法，将此线程需要执行的操作声明在call()中 3.创建Callable接口实现类的对象 4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象 5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start() import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.FutureTask; //1.创建一个实现Callable的实现类 class NumThread 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 ThreadNew { public static void main(String[] args) { //3.创建Callable接口实现类的对象 NumThread numThread = new NumThread(); //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象 FutureTask futureTask = new FutureTask(numThread); //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start() new Thread(futureTask).start(); try { //6.获取Callable中call方法的返回值 //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。 Object sum = futureTask.get(); System.out.println("总和为：" + sum); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } } }创建线程的方式四：使用线程池 好处： 1.提高响应速度（减少了创建新线程的时间） 2.降低资源消耗（重复利用线程池中线程，不需要每次都创建） 3.便于线程管理 corePoolSize：核心池的大小 maximumPoolSize：最大线程数 keepAliveTime：线程没有任务时最多保持多长时间后会终止
步骤：
提供指定线程数量的线程池执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象.关闭连接池 import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.ThreadPoolExecutor; /** 多线程有几种方式？四种！ */ class NumberThread implements Runnable{ @Override public void run() { for(int i = 0;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 = 0;i <= 100;i++){ if(i % 2 != 0){ System.out.println(Thread.currentThread().getName() + ": " + i); } } } } public class ThreadPool { public static void main(String[] args) { //1. 提供指定线程数量的线程池 ExecutorService service = Executors.newFixedThreadPool(10); ThreadPoolExecutor service1 = (ThreadPoolExecutor) service; //设置线程池的属性 // System.out.println(service.getClass()); // service1.setCorePoolSize(15); // service1.setKeepAliveTime(); //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象 service.execute(new NumberThread());//适合适用于Runnable service.execute(new NumberThread1());//适合适用于Runnable // service.submit(Callable callable);//适合使用于Callable //3.关闭连接池 service.shutdown(); } }五种状态：
- **新建：** 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态 - **就绪：**处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源 - **运行：**当就绪的线程被调度并获得CPU资源时,便进入运行状态， run()方法定义了线程的操作和功能 - **阻塞：**在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态 - **死亡：**线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束sleep() 和 wait() 有什么区别？
notify()：唤醒正在排队等待同步资源的线程中优先级最高者结束 notifyAll ()：唤醒正在排队等待资源的所有线程结束等待.
1 service.execute(new NumberThread1());//适合适用于Runnable 2 service.submit(Callable callable);//适合使用于Callable
synchronized 使用 synchronized的锁是什么？ - 任意对象都可以作为同步锁。所有对象都自动含有单一的锁（监视器）。 - 同步方法的锁：静态方法（类名.class）、非静态方法（this） - 同步代码块：自己指定，很多时候也是指定为this或类名.class 同步代码块：
synchronized (对象){ //需要被同步的代码; }同步方法 synchronized还可以放在方法声明中，表示整个方法为同步方法
public synchronized void show (String name){ //需要被同步的代码; }常使用字节码对象作为同步锁 示例代码
class Singleton{ private Singleton(){} private static Singleton instance = null; public static Singleton getInstance(){ if(instance == null){ synchronized (Singleton.class) { if(instance == null){ instance = new Singleton(); } } } return instance; } }Lock方式 从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用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的对比 1 Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized是隐式锁，出了作用域自动释放 2 Lock只有代码块锁，synchronized有代码块锁和方法锁 3 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类） 优先使用顺序： Lock --> 同步代码块（已经进入了方法体，分配了相应资源） --> 同步方法 （在方法体之外）
不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续 怎么防止死锁 死锁需要满族的四大条件如下： 互斥 循环等待 不可抢占 占有并等待 产生死锁的主要原因有： 系统资源不足 进程运行推进顺序不当 资源分配不当 防止死锁： 1、让程序每次至多只能获得一个锁。当然，在多线程环境下，这种情况通常并不现实 2、设计时考虑清楚锁的顺序，尽量减少嵌在的加锁交互数量 3、既然死锁的产生是两个线程无限等待对方持有的锁，那么只要等待时间有个上限不就好了。当然synchronized不具备这个功能，但是我们可以使用Lock类中的tryLock方法去尝试获取锁，这个方法可以指定一个超时时限，在等待超过该时限之后变回返回一个失败信息
参考：https://www.jianshu.com/p/d2ac26ca6525
wait()与notify()和notifyAll() wait()：令当前线程挂起并放弃CPU、同步资源并等待，使别的线程可访问并修改共享资源，而当前线程排队等候其他线程调用notify()或notifyAll()方法唤醒，唤醒后等待重新获得对监视器的所有权后才能继续执行。 notify()：唤醒正在排队等待同步资源的线程中优先级最高者结束等待 notifyAll ()：唤醒正在排队等待资源的所有线程结束等待.
class Communication implements Runnable { int i = 1; public void run() { while (true) { synchronized (this) { notify(); if (i <= 100) { System.out.println(Thread.currentThread().getName() + ":" + i++); } else break; try { wait(); } catch (InterruptedException e) { e.printStackTrace(); } } } } }本文参考：https://blog.csdn.net/duan196_118/article/details/104655857
