JAVASE(十七) 多线程：程序、进程、线程与线程的生命周期、死锁、单例、同步锁

个人博客网：https://wushaopei.github.io/ (你想要这里多有)

1、程序、进程、线程的理解

1.1 概念

程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。
进程(process)是程序的一次执行过程，或是正在运行的一个程序。动态过程：有它自身的产生、存在和消亡的过程。

如：运行中的QQ，运行中的MP3播放器
程序是静态的，进程是动态的

线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。

若一个程序可同一时间执行多个线程，就是支持多线程的

1.2 进程与多线程

每个Java程序都有一个隐含的主线程： main 方法

程序需要同时执行两个或多个任务。

程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。

需要一些后台运行的程序时。

2、多线程的创建和启动

2.1 Thread 线程概念：

2.2 源码流程解析：

（1）Thread 类与 Runnable接口

并且在Thread中有一个构造器的参数是Runnable的实现子类，所以当一个自定义类实现了Runnable接口后，可以通过newThread（）作为构造参数传入来实现Thread多线程的创建。

如图：

（2）Thread 与 Runnable 、Callable 及Future Task 的关系

首先分析：

Future Task的底层实现了RunnableFuture 接口：

而RunnableFuture 的底层实现了两个接口： Runnable , Future

而根据FutureTask 的构造方法和Callable 的类型可知：

由以上可以得知，通过自定义实现了Callable 接口的实例对象做为FutureTask 的构造器形参，然后因为实现了Runnable 接口的缘故，该对象可以做参数传入Thread对象的构造器中，用来创建新的多线程 thread ,并使用 start （）启动线程。

2.3 案例：mt子线程的创建和启动过程

3、线程中常用的API

interrupt() ： 中断线程（也会将当前线程中的任务执行完毕会进行线程的一个标记，标记该线程是要被停止。
isInterrupted() ：测试此线程是否已被中断。（如果线程的标记被标识成中断则返回true）

3、创建多线程的四中种方式

3.1 继承Thread

自定义一个类并继承Thread

重写run方法

run方法中可以写入需要在分线程中执行的代码

创建Thread子类的对象

通过对象调用start方法

3.2 实现Runnable接口

自定义一个类并实现Runnable接口

重写run方法

在run方法中写入需要在分线程中执行的代码

创建Runnable实现类的对象

创建Thread对象并将Runnable实现类的对象作为实参传入到Thread的构造器中

通过Thread对象调用start方法

3.3 实现Callable接口

自定义一个类，并实现Callable接口

重写call方法，并返回结果

在call方法中实现需要在分线程中执行的代码

创建Callable接口的实现类的对象

创建FutureTask对象，并将Callable接口的实现类的对象作为实参传到FutureTask的构造器中

创建Thread对象，并将FutureTask对象作为实参传入到Thread构造器中

调用start方法

代码：

public class ThreadTest {

	public static void main(String[] args) throws Exception {

		//4.创建Callable接口的实现类的对象

		MyCallble myCallble = new MyCallble();

		//5.创建FutureTask对象，并将Callable接口的实现类的对象作为实参传到FutureTask的构造器中

		FutureTask<Integer> futureTask = new FutureTask<>(myCallble);

		//6.创建Thread对象，并将FutureTask对象作为实参传入到Thread构造器中

		Thread thread = new Thread(futureTask);

		//7.调用start方法

		thread.start();

		//阻塞主线程，等待分线程返回数据结果，然后再向下执行。

		Integer intNumber = futureTask.get();

		System.out.println("===" + intNumber);

		System.out.println("aaaaaaaaaaaaaaaaaaa");

	}

}

//1.自定义一个类，并实现Callable接口

class MyCallble implements Callable<Integer>{

	//2.重写call方法，并返回结果

	@Override

	public Integer call() throws Exception {

		/*

		 * 3.需要在分线程中执行的代码

		 */

		for (int i = 0; i < 100; i++) {

			System.out.println(Thread.currentThread().getName() + " == " + i);

		}

		return 100;

	}

}

3.4 线程池

                //创建一个线程池，根据需要创建新的线程，但在可用时将重用先前构建的线程。

		ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();

		//创建一个线程池，使用固定数量的线程操作了共享无界队列。

		ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(3);

		//创建一个执行器，使用一个单一的工作线程操作关闭一个无限的队列。

		ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor();

newCachedThreadPool.execute(new Runnable() {

			@Override

			public void run() {

				for (int i = 0; i < 100; i++) {

					System.out.println(Thread.currentThread().getName() + "====" + i);

				}

			}

		});

		//关闭线程池

		newCachedThreadPool.shutdown();

4、Thread的生命周期

要想实现多线程，必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五种状态：

新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件
运行：当就绪的线程被调度并获得处理器资源时,便进入运行状态， run()方法定义了线程的操作和功能
阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态
死亡：线程完成了它的全部工作或线程被提前强制性地中止

5、线程的同步机制

5.1 为什么要使用线程的同步机制？

多个线程在同时操作共享数据的时候可能会发生线程安全问题。

比如卖票：会发生重票，0票，负票的问题

5.2 解决线程安全问题的方式？
解决方法一：同步代码块：
格式：

         synchronized (同步监视器) {

                //操作共 享数据的代码

         }

1.同步监视器：可以是任何对象
   注意：多个线程必须使用的是同一把锁（必须保证多个线程使用到的同步监视器是同一个对象）。
2.同步代码块内：操作共享数据的代码
（实现Runnable使用同步代码块案例：详见RunnableTest.java）

解决方法二： 同步方法
       格式：

        public synchronized void say(){}  -- 修饰普通方法

默认的同步监视器是：this

           public static synchronized void say(){} -- 修饰静态方法

默认的同步监视是运行时类的对象。例：Person.class

6、线程的单例模式

class Bank {

	private Bank() {

	}

	private static Bank bank = null;

	public static Bank getInstance() {

		if (bank == null) {

			synchronized (Bank.class) {

				if (bank == null) {

					bank = new Bank();

				}

			}

		}

		return bank;

	}

}

7、死锁的问题

死锁的原因：不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
代码：

                //创建两把锁

                StringBuffer s1 = new StringBuffer();

		StringBuffer s2 = new StringBuffer();

		new Thread() {

			public void run() {

				synchronized (s1) {

					s2.append("A");

					try {

						Thread.currentThread().sleep(10);

					} catch (InterruptedException e) {

						// TODO Auto-generated catch block

						e.printStackTrace();

					}

					synchronized (s2) {

						s2.append("B");

						System.out.print(s1);

						System.out.print(s2);

					}

				}

			}

		}.start();

		new Thread() {

			public void run() {

				synchronized (s2) {

					s2.append("C");

					try {

						Thread.currentThread().sleep(10);

					} catch (InterruptedException e) {

						// TODO Auto-generated catch block

						e.printStackTrace();

					}

					synchronized (s1) {

						s1.append("D");

						System.out.print(s2);

						System.out.print(s1);

					}

				}

			}

		}.start();

8、线程通信

8.1 线程通信涉及到三个方法：

注意：

上面个方法只能用在同步代码块和同步方法中
调用个方法实际上是调用监视对象中的方法

8.2 [面试题] wait和sleep的区别？

sleep睡觉的时候会抱着锁。wait睡觉的时候会释放锁。
sleep时间一到就自动唤醒，wait需要被其它线程调用notify/notifyAll才能唤醒。
sleep是Thread中的方法, wait是Object中的方法。

8.3 [面试题] 继承Thread和实现Runnable的区别？

继承Thread :

同步监视器：不可以使用this

共享资源：需要使用static关键字修饰。

单继承

public static synchronized void say() - 默认锁是运行时类的对象。比如： Person.class

实现Runnable

同步监视器：可以使用this

共享资源：不需要使用static关键字修饰。

多实现

public synchronized void say(){} - 默认锁是this

9、同步的优点和缺点

同步的优点：解决了线程安全问题
同步的缺点：在同步代码块和同步方法的方法体执行时，只能有一个线程在执行。效率低。

10、ReentrantLock

代码：

class MyRunnable2 implements Runnable {

	// 同一个类的多个对象共同拥有一份类变量

	private  int ticket = 100;

	private ReentrantLock lock = new ReentrantLock();

	@Override

	public void run() {

		while (true) {

			lock.lock(); //锁住当前的线程

			try {

				if (ticket > 0) {

					try {

						Thread.sleep(10);

					} catch (InterruptedException e) {

						e.printStackTrace();

					}

					System.out.println(Thread.currentThread().getName() + " ==== " + ticket);

					ticket--;

				} else {

					return;

				}

			} finally {

				//最后一定要手动解锁

				lock.unlock();

			}

		}

	}

}

注意：ReentrantLock使用到的线程通信不是使用的wait()和notify()