一，前提
一说到多线程，就不得不提进程，线程，程序的概念：
先说进程，一说到进程，就不能不说一下程序，程序是指令和数据的有序集合，其本身没有任何的含义，是一个静态的概念。而进程是执行程序的一次执行过程，它是个一个动态的概念，是系统资源分配的单元。
通常在一个进程中可以包含若干个线程，当然，一个进程中至少是有一个线程，不然没有存在的意义，线程是CPU调度和执行的单位。
Note: 很多多线程都是模拟出来的，真正的多线程是指多个cpu，即多核，如服务器。如果是模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，cpu只能执行一个代码，因为切换的很快，所有就由同时执行的错觉。
而对于多进程类似于下图的操作：
总结一下：
- 线程就是一个独立的执行单位。
- 在程序运行时，就算你没有自己创建进程进行编程，后台也会有多个线程在运行，如main，gc线程。
- main()主线程，作为程序的入口，用于执行整个程序。
- 在一个进程中，如果开辟了多个线程，线程的运行是由调度器安排调度的，调度器是和操作系统紧密相关，先后顺序是不能进行干预的。
- 对同一份资源操作时，会存在资源争夺的问题，需要加入并发控制。
- 线程会带来额外的开销，如cpu调度时间，并发控制开销。
- 每个线程都在自己的工作内存中工作，内存控制不当会造成数据不一致。
需要掌握的几部分
- 创建线程的几种方式
- 线程的安全问题与几种机制
- 线程之间的通信问题解决方案
二，线程的创建
多线程的创建方式，比较常规的说法是两种方式：1. 继承Thread类 2. 实现Runnable接口。
但是严格来说，有四种：3. 实现Callable接口。4. 线程池
2.1 继承Thread类
步骤：
- 创建一个 继承于Thread的子类
- 重写Thread类的 run方法 。（将此线程执行的操作声明在run方法中）
- 创建Thread类的子类对象
- 通过此对象调用**start()**方法
实例代码：
public static void main(String[] args) throws InterruptedException {
//. 创建Thread类的子类对象
MyThread t = new MyThread();
//. 通过此对象调用start()方法 : 1 .导致此线程开始执行 2.Java虚拟机调用此线程的run方法。
t.start();
// t.run (只是做了一个创建对象，然后调用对象中的方法操作，等调用的方法执行结束之后，才会执行下面的代码，
// 不会启动一个新的线程)
// 问题： 我们不能通过直接调用run方法的方式直接调用
// t.start();
// 问题： 在启动一个线程，遍历100以内的偶数。
// 再启动一个线程，不可以让已经start()的线程在去调用start()执行，否则会报 IllegalThreadStateException
// 需要重新创建一个对象来调用start()方法
MyThread t = new MyThread();
t.start();
// 如下的操作仍然是在main线程中执行的
for (int i =; i < 100; i++) {
if(i % == 0){
System.out.println(Thread.currentThread().getName() + " ======main======== " + i);
}
}
}
}
//. 创建一个继承于Thread的子类。
class MyThread extends Thread{
//. 重写Thread类的run方法。
@Override
public void run() {
for (int i =; i < 100; i++) {
if(i % == 0){
System.out.println(Thread.currentThread().getName()+ " ========= ======" + i);
}
}
}
2.2 实现Runnable接口
步骤：
- 创建一个是实现了Runnable接口的一个类。
- 实现类去实现Runnable接口中的抽象方法：run()
- 创建实现类的对象
- 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象。
- 通过Thread类的对象调用start()方法
代码：
/. 创建一个实现了Runnable接口的一个类。
class MThread implements Runnable {
//. 实现类去实现Runnable中的抽象方法：run()
@Override
public void run() {
for (int i =; i < 100; i++) {
if (i % == 0) {
System.out.println(Thread.currentThread().getName() + " === " + i);
}
}
}
}
public class A_ThreadTest {
public static void main(String[] args) {
//. 创建实现类的对象
MThread mThread = new MThread();
//. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象。
Thread t = new Thread(mThread);
//. 通过Thread类的对象调用start(); 作用： 1. 启动线程
//.调用当前线程的run()方法 --- > 调用了Runnable类型中target的run()方法
t.start();
// 在创建一个线程
Thread t = new Thread(mThread);
t.start();
}
}
除了以上有通过实现Runnable接口和继承Thread类的方式来创建线程之外，还有两种方法是JDK5新增的两种方法来创建线程。
2.3 实现callable接口
如何理解callable接口的方式创建线程的方式比实现Runnable接口创建线程的方式要强大？
- call() 方法是可以有返回值的。
- call() 可以抛出异常，被外面的操作捕获。
- callable() 是支持泛型的。
代码实例：
//.创建一个实现callable的实现类
class NumThread implements Callable{
//. 实现call方法，将此线程需要执行的操作声明在call方法中
@Override
public Object call() throws Exception {
int sum =;
for (int i =; i <= 100; i++) {
if (i % == 0) {
System.out.println(i);
sum += i;
}
}
return sum;
}
}
public class ThreadNew {
public static void main(String[] args) throws ExecutionException, InterruptedException {
//. 创建callable接口实现类的对象
NumThread t = new NumThread();
//. 将此callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
FutureTask futureTask = new FutureTask(t);
//. 将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start方法
new Thread(futureTask).start();
//. 获取callable中call方法中的返回值
// get 方法的返回值，就为futuretask构造器参数callable实现类重写的call方法的返回值
int sum = (Integer)futureTask.get();
System.out.println("总和为" + sum);
}
}
2.4 线程池
好处：
- 提高相应速度（减少了创建新线程的时间）
- 减低资源消耗（重复利用线程池中线程，不需要每次创建）
- 便于线程管理
代码示例：
class NumberThread implements Runnable{
@Override
public void run() {
for (int i =; i <= 100; i++) {
if (i % == 0) {
System.out.println(Thread.currentThread().getName() + " ::" + i);
}
}
}
}
class NumberThread implements Runnable{
@Override
public void run() {
for (int i =; i <= 100; i++) {
if (i % == 0) {
System.out.println(Thread.currentThread().getName() + " ::" + i);
}
}
}
}
public class ThreadPool {
public static void main(String[] args) {
//.提供指定数量的线程池
ThreadPoolExecutor service = (ThreadPoolExecutor) Executors.newFixedThreadPool();
// 设置线程池属性
service.setCorePoolSize();
// service.setKeepAliveTime();
//. 执行执行线程的操作，需要提供Runnable接口或者是Callable接口实现类的对象
service.execute(new NumberThread()); // 适合使用runnable
service.execute(new NumberThread()); // 适合使用runnable
// service.submit(); // 适合使用与callable
//.关闭连接池
service.shutdown();
}
}
三，线程安全问题
在进行买票问题的分析上，发现了有可能票数会出现不一致的情况，所以需要一定的安全机制来避免这种情况。
出现原因：某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票。
如何解决：
当一个线程在操作ticket的时候， 其他线程不能参与进来，直到当前线程操作完毕之后，其他线程才可以操作ticket，即是是当前线程出现了堵塞，情况也不能改变。
在java中主要通过同步机制来解决线程的安全问题：
实现同步机制有以下几种方式：
3.1 同步代码块
【语法】
synchronized(同步监视器){
// 需要被同步的代码
}
说明分析：
- 操作共享数据的代码，即为需要被同步的代码。（不能包含多了，有可能会出错），也不能包含少。
- 共享数据：多个线程共同操作的变量。
- 同步监视器：俗称“锁”。任何一个对象，都可以充当锁。
- 要求：多个线程必须公用公用一把锁。(调用的时候，传入的是同一个对象)。`
补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器
一定是只是创建了一个Runnable接口的对象传入到Thread中的构造方法中，才能保证是同一个对象
在实现Runnable接口的实现类中使用同步代码块解决安全机制：
class Window implements Runnable {
private int ticket =;
Object lock = new Object();
@Override
public void run() {
while (true) {
// 由于只是new了一个对象，所以，可以使用this关键字来进行代替 此时的this代表的就是window的对象
synchronized(lock){
if (ticket >) {
// 将程序进行缓慢执行.1秒
try {
Thread.sleep();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "：买票， 票号是" + ticket);
ticket--;
} else {
break;
}
}
}
}
}
// 【实现的方式解决线程安全问题】
public class C_WindowTest1 {
public static void main(String[] args) {
// 由于只是new了一个window的对象，所以Window类中多个线程都是共享一个lock对象
Window w = new Window1();
// 在构造方法中传入实现了runnable接口的类
Thread t = new Thread(w);
Thread t = new Thread(w);
Thread t = new Thread(w);
// 命名操作
t.setName("窗口一");
t.setName("窗口二");
t.setName("窗口三");
// start()开启线程
t.start();
t.start();
t.start();
}
}
需要注意的是：由于实现了Runnable的这个类只是new了一个对象，所以成员变量 Object lock = new Object(); 的对象所有的线程属于是同一个，所以可以达到同步的目的。
如果是 继承Thread的方式实现多线程的方式，需要注意的是需要把锁的对象声明成static，才能使所有的线程都是共享一个lock的变量 。
class Window extends Thread {
// 出现线程安全问题
private static int ticket =;
// private Object lock = new Object(); 由于同步代码块中的锁不是同一个，所以出现了没有解决同步安全的现象，只要把所有的锁对象换成
// 同一个，那么就可以解决同步的问题，解决方案是，让他们共享同一个对象
private static Object lock = new Object(); // 解决了线程安全的问题
@Override
public void run() {
while (true) {
// 不能使用this关键字作为同步锁 this代表着 t , t2, t3三个对象
// synchronized(Window.class){ 但是可以他们是公用一个类对象，所以，通用一个类对象来进行。类只会加载一次。
synchronized(lock){
if (ticket >) {
try {
Thread.sleep();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(getName() + ":买票， 票号是： " + ticket);
ticket--;
}else{
break;
}
}
}
}
}
public class C_WindowTest2 {
public static void main(String[] args) {
// 创建三个对象
Window w1 = new Window2();
Window w2 = new Window2();
Window w3 = new Window2();
// 命名
w.setName("窗口一");
w.setName("窗口二");
w.setName("窗口三");
// 启动线程
w.start();
w.start();
w.start();
}
}
需要注意的是，锁一定要是同一个。
3.2 同步方法
如果操作共享数据的代码完整的声明在一个方法中，我们不妨考虑将此方法声明为同步的。
【使用实现Runnable接口的方式解决线程安全问题】
public class ThreadTest {
public static void main(String[] args) {
Window target = new Window();
// 创建线程Thread
Thread t = new Thread(target);
Thread t = new Thread(target);
Thread t = new Thread(target);
t.setName("window - one");
t.setName("window - two");
t.setName("window - three");
t.start();
t.start();
t.start();
}
}
class Window implements Runnable{
// 总的票数 所有的实例对象只有一个
private static int ticket =;
@Override
public void run() {
while (true) {
if (show()) break;
}
}
// 使用关键字synchronized来将show方法作为一个同步方法来解决同步问题
private synchronized boolean show() {
if (ticket >) {
System.out.println(Thread.currentThread().getName() + "买票，买票的票号是" + ticket);
ticket --;
} else{
return true;
}
return false;
}
}
原理分析： 由于此时的this，在Runnable只是创建了一个对象，所以，this对象可以为多个线程公用同一把锁。同步方法默认是使用当前对象的this作为同步的锁。
如果是使用继承Thread类的方法解决线程安全问题的写法又是会有些不同。
【使用继承Thread类方法的方式解决线程安全问题】
public class ThreadTest {
public static void main(String[] args) {
// 创建线程
Window t1 = new Window2();
Window t2 = new Window2();
Window t3 = new Window2();
// 设置名字
t.setName("window-one");
t.setName("window-two");
t.setName("window-three");
// 启动多个线程
t.start();
t.start();
t.start();
}
}
class Window extends Thread{
private static int ticket =;
private static Object lock = new Object();
@Override
public void run() {
while (true) {
if (show()) break;
}
}
// 由于此时的调用当前同步方法的对象不是同一个，所以this指代的也不是同一个，所以进行同步方法的时候，需要加上一个static,保证锁是同一把锁
private static synchronized boolean show() {
if (ticket >) {
System.out.println(Thread.currentThread().getName() + "买票，买票的票号是" + ticket);
ticket --;
} else{
return true;
}
return false;
}
}
注意：此时需要注意的是，在同步方法中，由于同步方法默认使用的是调用当前方法的this作为多个线程的同步监视器，所以，如果不声明成静态的方法，则this指示的是不同的对象，所以，需要声明程静态方法。
3.3 加锁实现同步
3.3.1ReentrantLock 锁
一种新的实现线程之间同步的方式：
- 创建一个ReentrantLock锁
ReentrantLock lock = new ReentrantLock(true);
2.在需要同步的关键地方加锁
lock.lock();
3.线程同步代码结束之后需要进行解锁操作。
lock.unlock();
详细请看：
四. 线程通信问题
设计到三个方法
注意事项：
代码示例：
class Number implements Runnable{
private int number =;
private Object obj = new Object();
@Override
public void run() {
while (true) {
// 利用同步代码块
synchronized (obj) {
// notifyall() 是唤醒所有的堵塞线程 notify按照优先级的高低，释放优先级最高的线程
obj.notify();
if (number <=) {
try {
Thread.sleep();
} 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 t = new Thread(number);
Thread t = new Thread(number);
// 命名
t.setName("线程1");
t.setName("线程2");
// 启动
t.start();
t.start();
}
}
五，总结与概括
5.1 线程中两种创建方式（继承Thread和实现Runnable接口）的对比
无论是哪种方法，切入点都是Thread类，区别是：
继承 Thread类的顺序是： Thread.start() -> Thread.run()
实现Runnable 接口的顺序是： Thread.start() -> Thread.run() -> Runnable .run()
Runnable接口：天然的实现数据共享，如果继承，则需要设置为静态的。
开发中：优先选择Runnable接口的方式。
原因：
- 实现的方式没有类的单继承的局限性。2. 实现的方式更适合来处理多个线程共享数据的情况。
联系: class Thread implements Runnable
不管是继承还是实现的方式，都需要重写Runnable接口，都需要重写run()方法，将线程需要执行的逻辑声明在run()中。
5.2 同步方法总结
关于同步方法的总结：
1.同步方法仍然设计到同步监视器，只是不需要我们显示的进行声明。
2.非静态的同步方法，同步监视器是：this。
3.静态的同步方法，同步监视器是当前类本身
同步的方式，解决了线程安全问题 — 好处
操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。
finally
you cannot swim for new horizons until you have courage to lose sight of the shore.
