多线程概述

1. 线程与进程

进程
是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间

线程
是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行. 一个进程最少 有一个线程 。
线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分 成若干个线程。

2. 线程调度

1. 分时调度：
   所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。
2. 优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)。
   CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核新而言，某个时刻， 只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是 在同一时 刻运行。 其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的 使 用率更高。

3. 线程的同步与异步

同步： 排队执行，效率低但是安全
异步： 同时执行， 效率高但是数据不安全.

Java简单实现多线程

1. Thread类

通过继承Thread类Override类方法run进行多线程
例：

public class MyThread extends Thread {/*** run方法是线程要执行的任务方法*/@Overridepublic void run() {// 这里的代码是一条新的执行路径// 这个执行路径的出发方式，不是调用run而是通过thread对象的start()来启动for(int i = 0; i < 10; i++) {System.out.println("haha" + i);}}
}

public class Demo {public static void main(String[] args) {MyThread m = new MyThread();m.start();for(int i = 0; i < 10; i++) {System.out.println("xixi" + i);}}
}

haha0
haha1
haha2
haha3
xixi0
xixi1
xixi2
xixi3
haha4
xixi4
haha5
xixi5
haha6
xixi6
haha7
haha8
haha9
xixi7
xixi8
xixi9

线程打印haha会和主方法里面打印xixi交替运行，顺讯不固定。

2. Runnable

通过实施Runnable接口来实现多线程

public class MyRunnable implements Runnable{/*** 用于给线程执行的任务*/@Overridepublic void run() {for(int i = 0; i < 10; i++) {System.out.println("haha" + i);}}
}

public class Demo {public static void main(String[] args) {// 实现Runnable// 创建一个任务对象MyRunnable r = new MyRunnable();// 创建一个线程，并为其分配一个任务Thread t = new Thread(r);// 执行线程t.start();for(int i = 0; i < 10; i++) {System.out.println("xixi" + i);}}
}

实现Runnable与继承Thread有如下优势：

1. 通过创建任务然后给线程分配的方式来实现多线程，更适合多个线程同时执行相同任务情况。
2. 避免单继承所带来的局限性。
3. 任务与线程本身是分离的提高了程序的健壮性
4. 后续的线程池技术接受Runnable，不接受Thread类型的线程。

3. 线程中断

一个线程是一个独立的执行路径，他是否应该结束，应该由其自身决定。
早起java提供了Thread.stop()方法从外部掐断线程，但是这样做会导致线程使用的资源来不及释放。现在已经为过时方法。
现在我们使用给线程打断点的方式中断线程
例： 实现线程中断

public class MyRunnable implements Runnable{/*** 用于给线程执行的任务*/@Overridepublic void run() {for(int i = 0; i < 10; i++) {System.out.println(Thread.currentThread().getName() + ":" + i);try {Thread.sleep(1000);} catch (InterruptedException e) {System.out.println("发现中断标记，线程停止");return; // 资源释放}}}
}

public class Demo3 {public static void main(String[] args) {MyRunnable m = new MyRunnable();Thread t1 = new Thread(new Thread(m));t1.start();for(int i = 0; i < 5; i++) {System.out.println(i);try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}t1.interrupt(); // 给子线程一个中断标记}
}

主线程for循环走完后会给interrupt标记进入子进程catch，然后子进程自我结束释放资源。

3. 线程安全问题

线程不安全是由于多个线程同时进行同时操作一个数据导致数据运行不符合预期。
线程不安全例子：

public class Demo4 {public static void main(String[] args) {// 线程不安全Runnable r = new Ticket();new Thread(r).start();new Thread(r).start();new Thread(r).start();}static class Ticket implements Runnable {// 卖票票数private int count = 10;@Overridepublic void run() {while(count > 0) {System.out.println("准备卖票");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}count--;System.out.println("出票成功， 余票：" + count);}}}
}

准备卖票
准备卖票
准备卖票
出票成功， 余票：9
准备卖票
出票成功， 余票：9
准备卖票
出票成功， 余票：9
准备卖票
出票成功， 余票：7
准备卖票
出票成功， 余票：7
准备卖票
出票成功， 余票：7
准备卖票
出票成功， 余票：6
准备卖票
出票成功， 余票：6
准备卖票
出票成功， 余票：6
准备卖票
出票成功， 余票：4
准备卖票
出票成功， 余票：4
准备卖票
出票成功， 余票：3
准备卖票
出票成功， 余票：2
准备卖票
出票成功， 余票：2
准备卖票
出票成功， 余票：2
准备卖票
出票成功， 余票：1
准备卖票
出票成功， 余票：1
准备卖票
出票成功， 余票：1
准备卖票
出票成功， 余票：0
出票成功， 余票：-2
出票成功， 余票：-2Process finished with exit code 0

可以看到最后count结果是-2

解决方案：排队执行
1. 同步代码块
使用synchronized和锁类实现线程排队执行

public class Demo4 {public static void main(String[] args) {// 线程不安全// 解决方案1同步代码块// 格式synchronized(锁对象) {//// }Runnable r = new Ticket();new Thread(r).start();new Thread(r).start();new Thread(r).start();}static class Ticket implements Runnable {// 卖票票数private int count = 10;Object o = new Object(); // 定义一个锁对象o@Overridepublic void run() {while(true) {synchronized (o) { // 使用锁同步代码块if(count > 0) {System.out.println("准备卖票");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}count--;System.out.println(Thread.currentThread().getName() + "出票成功， 余票：" + count);} else {break;}}}}}
}

准备卖票
Thread-0出票成功， 余票：9
准备卖票
Thread-0出票成功， 余票：8
准备卖票
Thread-0出票成功， 余票：7
准备卖票
Thread-0出票成功， 余票：6
准备卖票
Thread-0出票成功， 余票：5
准备卖票
Thread-0出票成功， 余票：4
准备卖票
Thread-0出票成功， 余票：3
准备卖票
Thread-0出票成功， 余票：2
准备卖票
Thread-0出票成功， 余票：1
准备卖票
Thread-0出票成功， 余票：0Process finished with exit code 0

2. 同步方法
给方法添加synchronized修饰符来实现同步方法

public class Demo4 {public static void main(String[] args) {// 线程不安全// 解决方案1同步代码块// 格式synchronized(锁对象) {// // }Runnable r = new Ticket();new Thread(r).start();new Thread(r).start();new Thread(r).start();}static class Ticket implements Runnable {// 卖票票数private int count = 10;Object o = new Object(); // 定义一个锁对象o@Overridepublic void run() {while(true) {sale();
//                synchronized (o) {
//
//                }}}public synchronized boolean sale() { //给方法添加synchronized修饰符来实现同步方法if(count > 0) {System.out.println("准备卖票");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}count--;System.out.println(Thread.currentThread().getName() + "出票成功， 余票：" + count);}return false;}}
}

3. 显示锁
同步代码块和同步方法属于隐式锁
例：

public class Demo4 {public static void main(String[] args) {// 线程不安全// 解决方案1同步代码块// 格式synchronized(锁对象) {//// }Runnable r = new Ticket();new Thread(r).start();new Thread(r).start();new Thread(r).start();}static class Ticket implements Runnable {// 卖票票数private int count = 10;// 显式锁l, ReentrantLock fair参数为true 就表示是公平锁（先来后到）Lock l = new ReentrantLock(true); @Overridepublic void run() {while (true) {l.lock(); // 进程执行时锁上if (count > 0) {System.out.println("准备卖票");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}count--;System.out.println(Thread.currentThread().getName() + "出票成功， 余票：" + count);} else {break;}l.unlock(); // 执行完毕解锁}}}
}

4. 线程的六种状态

1. 初始(NEW)：新创建了一个线程对象，但还没有调用start()方法。
2. 运行(RUNNABLE)：Java线程中将就绪（ready）和运行中（running）两种状态笼统的称为“运行”。
   线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取CPU的使用权，此时处于就绪状态（ready）。就绪状态的线程在获得CPU时间片后变为运行中状态（running）。
3. 阻塞(BLOCKED)：表示线程阻塞于锁。
4. 等待(WAITING)：进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。
5. 超时等待(TIMED_WAITING)：该状态不同于WAITING，它可以在指定的时间后自行返回。
6. 终止(TERMINATED)：表示该线程已经执行完毕。

5. Runnable

Runnable 与 Callable
Callable接口类似于Runnable ，因为它们都是为其实例可能由另一个线程执行的类而设计的。 但是， Runnable不会返回结果，也不能抛出已检查的异常。

接口定义

//Callable接口
public interface Callable<V> {    V call() throws Exception; 
} 
//Runnable接口
public interface Runnable {    public abstract void run(); 
}

Callable使用步骤

例：

public class Demo6 {public static void main(String[] args) throws ExecutionException, InterruptedException {Callable<Integer> c = new Mycallable();FutureTask<Integer> task = new FutureTask<>(c);new Thread(task).start();Integer j = task.get();System.out.println("返回值为： " + j);for(int i = 0; i < 10; i++) {try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(i);}}static class Mycallable implements Callable<Integer> {@Overridepublic Integer call() throws Exception {Thread.sleep(3000);return 100;}}
}

返回值为： 100
0
1
2
3
4
5
6
7
8
9

6. 线程池

如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程 就会大大降低 系统的效率，因为频繁创建线程和销毁线程需要时间. 线程池就是一个容纳多个线程的容 器，池中的线程可以反复使用，省去了频繁创建线程对象的操作，节省了大量的时间和资源

Java中的四种线程池 . ExecutorService
1. 缓存线程池

2. 定长线程池

3. 单线程线程池

4. 周期性任务定长线程池