一说到多线程，就不得不提进程，线程，程序的概念：

先说进程，一说到进程，就不能不说一下程序，程序是指令和数据的有序集合，其本身没有任何的含义，是一个静态的概念。而进程是执行程序的一次执行过程，它是个一个动态的概念，是系统资源分配的单元。

通常在一个进程中可以包含若干个线程，当然，一个进程中至少是有一个线程，不然没有存在的意义，线程是CPU调度和执行的单位。

Note: 很多多线程都是模拟出来的，真正的多线程是指多个cpu，即多核，如服务器。如果是模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，cpu只能执行一个代码，因为切换的很快，所有就由同时执行的错觉。

而对于多进程类似于下图的操作：

总结一下：

1. 线程就是一个独立的执行单位。
2. 在程序运行时，就算你没有自己创建进程进行编程，后台也会有多个线程在运行，如main，gc线程。
3. main()主线程，作为程序的入口，用于执行整个程序。
4. 在一个进程中，如果开辟了多个线程，线程的运行是由调度器安排调度的，调度器是和操作系统紧密相关，先后顺序是不能进行干预的。
5. 对同一份资源操作时，会存在资源争夺的问题，需要加入并发控制。
6. 线程会带来额外的开销，如cpu调度时间，并发控制开销。
7. 每个线程都在自己的工作内存中工作，内存控制不当会造成数据不一致。

1. 创建线程的几种方式
2. 线程的安全问题与几种机制
3. 线程之间的通信问题解决方案

多线程的创建方式，比较常规的说法是两种方式：1. 继承Thread类 2. 实现Runnable接口。

但是严格来说，有四种：3. 实现Callable接口。4. 线程池

步骤：

1. 创建一个 继承于Thread的子类
2. 重写Thread类的 run方法 。（将此线程执行的操作声明在run方法中）
3. 创建Thread类的子类对象
4. 通过此对象调用**start()**方法

实例代码：

public static void main(String[] args) throws InterruptedException { // 3. 创建Thread类的子类对象 MyThread t1 = new MyThread(); // 4. 通过此对象调用start()方法 : 1 .导致此线程开始执行 2.Java虚拟机调用此线程的run方法。 t1.start(); // t1.run (只是做了一个创建对象，然后调用对象中的方法操作，等调用的方法执行结束之后，才会执行下面的代码， // 不会启动一个新的线程) // 问题1： 我们不能通过直接调用run方法的方式直接调用 // t1.start(); // 问题2： 在启动一个线程，遍历100以内的偶数。 // 再启动一个线程，不可以让已经start()的线程在去调用start()执行，否则会报 IllegalThreadStateException // 需要重新创建一个对象来调用start()方法 MyThread t2 = new MyThread(); t2.start(); // 如下的操作仍然是在main线程中执行的 for (int i = 0; i < 100; i++) { if(i % 2 == 0){ System.out.println(Thread.currentThread().getName() + " ======main======== " + i); } } } } // 1. 创建一个继承于Thread的子类。 class MyThread extends Thread{ // 2. 重写Thread类的run方法。 @Override public void run() { for (int i = 0; i < 100; i++) { if(i % 2 == 0){ System.out.println(Thread.currentThread().getName()+ " ========= ======" + i); } } }2.2 实现Runnable接口

步骤：

1. 创建一个是实现了Runnable接口的一个类。
2. 实现类去实现Runnable接口中的抽象方法：run()
3. 创建实现类的对象
4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象。
5. 通过Thread类的对象调用start()方法

代码：

/ 1. 创建一个实现了Runnable接口的一个类。 class MThread implements Runnable { // 2. 实现类去实现Runnable中的抽象方法：run() @Override public void run() { for (int i = 0; i < 100; i++) { if (i % 2 == 0) { System.out.println(Thread.currentThread().getName() + " === " + i); } } } } public class A_03ThreadTest { public static void main(String[] args) { // 3. 创建实现类的对象 MThread mThread = new MThread(); // 4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象。 Thread t1 = new Thread(mThread); // 5. 通过Thread类的对象调用start(); 作用： 1. 启动线程 // 2.调用当前线程的run()方法 --- > 调用了Runnable类型中target的run()方法 t1.start(); // 在创建一个线程 Thread t2 = new Thread(mThread); t2.start(); } }

除了以上有通过实现Runnable接口和继承Thread类的方式来创建线程之外，还有两种方法是JDK5新增的两种方法来创建线程。

如何理解callable接口的方式创建线程的方式比实现Runnable接口创建线程的方式要强大？

1. call() 方法是可以有返回值的。
2. call() 可以抛出异常，被外面的操作捕获。
3. callable() 是支持泛型的。

代码实例：

// 1.创建一个实现callable的实现类 class NumThread implements Callable{ // 2. 实现call方法，将此线程需要执行的操作声明在call方法中 @Override public Object call() throws Exception { int sum = 0; for (int i = 0; i <= 100; i++) { if (i % 2 == 0) { System.out.println(i); sum += i; } } return sum; } } public class ThreadNew { public static void main(String[] args) throws ExecutionException, InterruptedException { // 3. 创建callable接口实现类的对象 NumThread t = new NumThread(); // 4. 将此callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象 FutureTask futureTask = new FutureTask(t); // 5. 将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start方法 new Thread(futureTask).start(); // 6. 获取callable中call方法中的返回值 // get 方法的返回值，就为futuretask构造器参数callable实现类重写的call方法的返回值 int sum = (Integer)futureTask.get(); System.out.println("总和为" + sum); } }2.4 线程池

好处：

1. 提高相应速度（减少了创建新线程的时间）
2. 减低资源消耗（重复利用线程池中线程，不需要每次创建）
3. 便于线程管理

代码示例：

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.提供指定数量的线程池 ThreadPoolExecutor service = (ThreadPoolExecutor) Executors.newFixedThreadPool(10); // 设置线程池属性 service.setCorePoolSize(100); // service.setKeepAliveTime(1000); // 2. 执行执行线程的操作，需要提供Runnable接口或者是Callable接口实现类的对象 service.execute(new NumberThread()); // 适合使用runnable service.execute(new NumberThread1()); // 适合使用runnable // service.submit(); // 适合使用与callable // 3.关闭连接池 service.shutdown(); } }三，线程安全问题

在进行买票问题的分析上，发现了有可能票数会出现不一致的情况，所以需要一定的安全机制来避免这种情况。

出现原因：某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票。

如何解决：

当一个线程在操作ticket的时候， 其他线程不能参与进来，直到当前线程操作完毕之后，其他线程才可以操作ticket，即是是当前线程出现了堵塞，情况也不能改变。

在java中主要通过同步机制来解决线程的安全问题：

实现同步机制有以下几种方式：

【语法】 synchronized(同步监视器){ // 需要被同步的代码 }

说明分析：

1. 操作共享数据的代码，即为需要被同步的代码。（不能包含多了，有可能会出错），也不能包含少。
2. 共享数据：多个线程共同操作的变量。
3. 同步监视器：俗称“锁”。任何一个对象，都可以充当锁。
   要求：多个线程必须公用公用一把锁。(调用的时候，传入的是同一个对象)。`

补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器

一定是只是创建了一个Runnable接口的对象传入到Thread中的构造方法中，才能保证是同一个对象

在实现Runnable接口的实现类中使用同步代码块解决安全机制：

class Window1 implements Runnable { private int ticket = 100; Object lock = new Object(); @Override public void run() { while (true) { // 由于只是new了一个对象，所以，可以使用this关键字来进行代替 此时的this代表的就是window1的对象 synchronized(lock){ if (ticket > 0) { // 将程序进行缓慢执行0.1秒 try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "：买票， 票号是" + ticket); ticket--; } else { break; } } } } } // 【实现的方式解决线程安全问题】 public class C_01WindowTest1 { public static void main(String[] args) { // 由于只是new了一个window的对象，所以Window1类中多个线程都是共享一个lock对象 Window1 w = new Window1(); // 在构造方法中传入实现了runnable接口的类 Thread t1 = new Thread(w); Thread t2 = new Thread(w); Thread t3 = new Thread(w); // 命名操作 t1.setName("窗口一"); t2.setName("窗口二"); t3.setName("窗口三"); // start()开启线程 t1.start(); t2.start(); t3.start(); } }

需要注意的是：由于实现了Runnable的这个类只是new了一个对象，所以成员变量 Object lock = new Object(); 的对象所有的线程属于是同一个，所以可以达到同步的目的。

如果是 继承Thread的方式实现多线程的方式，需要注意的是需要把锁的对象声明成static，才能使所有的线程都是共享一个lock的变量 。

class Window2 extends Thread { // 出现线程安全问题 private static int ticket = 100; // private Object lock = new Object(); 由于同步代码块中的锁不是同一个，所以出现了没有解决同步安全的现象，只要把所有的锁对象换成 // 同一个，那么就可以解决同步的问题，解决方案是，让他们共享同一个对象 private static Object lock = new Object(); // 解决了线程安全的问题 @Override public void run() { while (true) { // 不能使用this关键字作为同步锁 this代表着 t1 , t2, t3三个对象 // synchronized(Window2.class){ 但是可以他们是公用一个类对象，所以，通用一个类对象来进行。类只会加载一次。 synchronized(lock){ if (ticket > 0) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(getName() + ":买票， 票号是： " + ticket); ticket--; }else{ break; } } } } } public class C_02WindowTest2 { public static void main(String[] args) { // 创建三个对象 Window2 w1 = new Window2(); Window2 w2 = new Window2(); Window2 w3 = new Window2(); // 命名 w1.setName("窗口一"); w2.setName("窗口二"); w3.setName("窗口三"); // 启动线程 w1.start(); w2.start(); w3.start(); } }

需要注意的是，锁一定要是同一个。

如果操作共享数据的代码完整的声明在一个方法中，我们不妨考虑将此方法声明为同步的。

【使用实现Runnable接口的方式解决线程安全问题】

public class ThreadTest04 { public static void main(String[] args) { Window target = new Window(); // 创建线程Thread Thread t1 = new Thread(target); Thread t2 = new Thread(target); Thread t3 = new Thread(target); t1.setName("window - one"); t2.setName("window - two"); t3.setName("window - three"); t1.start(); t2.start(); t3.start(); } } class Window implements Runnable{ // 总的票数 所有的实例对象只有一个 private static int ticket = 100; @Override public void run() { while (true) { if (show()) break; } } // 使用关键字synchronized来将show方法作为一个同步方法来解决同步问题 private synchronized boolean show() { if (ticket > 0) { System.out.println(Thread.currentThread().getName() + "买票，买票的票号是" + ticket); ticket --; } else{ return true; } return false; } }

原理分析： 由于此时的this，在Runnable只是创建了一个对象，所以，this对象可以为多个线程公用同一把锁。同步方法默认是使用当前对象的this作为同步的锁。

如果是使用继承Thread类的方法解决线程安全问题的写法又是会有些不同。

【使用继承Thread类方法的方式解决线程安全问题】

public class ThreadTest05 { public static void main(String[] args) { // 创建线程 Window2 t1 = new Window2(); Window2 t2 = new Window2(); Window2 t3 = new Window2(); // 设置名字 t1.setName("window-one"); t2.setName("window-two"); t3.setName("window-three"); // 启动多个线程 t1.start(); t2.start(); t3.start(); } } class Window2 extends Thread{ private static int ticket = 100; private static Object lock = new Object(); @Override public void run() { while (true) { if (show()) break; } } // 由于此时的调用当前同步方法的对象不是同一个，所以this指代的也不是同一个，所以进行同步方法的时候，需要加上一个static,保证锁是同一把锁 private static synchronized boolean show() { if (ticket > 0) { System.out.println(Thread.currentThread().getName() + "买票，买票的票号是" + ticket); ticket --; } else{ return true; } return false; } }

注意：此时需要注意的是，在同步方法中，由于同步方法默认使用的是调用当前方法的this作为多个线程的同步监视器，所以，如果不声明成静态的方法，则this指示的是不同的对象，所以，需要声明程静态方法。

一种新的实现线程之间同步的方式：

1. 创建一个ReentrantLock锁

ReentrantLock lock = new ReentrantLock(true);

2.在需要同步的关键地方加锁

lock.lock();

3.线程同步代码结束之后需要进行解锁操作。

lock.unlock();

详细请看：

https://blog.csdn.net/Zheng548/article/details/54426947

设计到三个方法

注意事项：

代码示例：

class Number implements Runnable{ private int number = 1; private Object obj = new Object(); @Override public void run() { while (true) { // 利用同步代码块 synchronized (obj) { // notifyall() 是唤醒所有的堵塞线程 notify按照优先级的高低，释放优先级最高的线程 obj.notify(); if (number <= 100) { try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + ":" + number); number++; // 使用调用如下wait()方法的线程进入到堵塞状态，wait是会释放锁 try { obj.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } else { break; } } } } } public class CommunicationTest { public static void main(String[] args) { Number number = new Number(); // 创建两个Thread对象 Thread t1 = new Thread(number); Thread t2 = new Thread(number); // 命名 t1.setName("线程1"); t2.setName("线程2"); // 启动 t1.start(); t2.start(); } }五，总结与概括5.1 线程中两种创建方式（继承Thread和实现Runnable接口）的对比

无论是哪种方法，切入点都是Thread类，区别是：

继承 Thread类的顺序是： Thread.start() -> Thread.run()
实现Runnable 接口的顺序是： Thread.start() -> Thread.run() -> Runnable .run()

Runnable接口：天然的实现数据共享，如果继承，则需要设置为静态的。

开发中：优先选择Runnable接口的方式。

原因：

1. 实现的方式没有类的单继承的局限性。2. 实现的方式更适合来处理多个线程共享数据的情况。

联系: class Thread implements Runnable

不管是继承还是实现的方式，都需要重写Runnable接口，都需要重写run()方法，将线程需要执行的逻辑声明在run()中。

关于同步方法的总结：

​ 1.同步方法仍然设计到同步监视器，只是不需要我们显示的进行声明。

​ 2.非静态的同步方法，同步监视器是：this。

​ 3.静态的同步方法，同步监视器是当前类本身

同步的方式，解决了线程安全问题 — 好处

操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。

you cannot swim for new horizons until you have courage to lose sight of the shore.