Java多线程之基础
1 并发与并行
并发：指两个或多个事件在同一个时间段内发生。
并行：指两个或多个事件在同一时刻发生（同时发生）。
并发指的是在一段时间内宏观上有多个程序同时运行：
- 在单 CPU 系统中，每一时刻只能有一道程序执行，即微观上这些程序是分时的交替运行，只不过是给人的感觉是同时运行，那是因为分时交替运行的时间是非常短的。
- 在多个 CPU 系统中，则这些可以并发执行的程序便可以分配到多个处理器上（CPU），实现多任务并行执行，即利用每个处理器来处理一个可以并发执行的程序，这样多个程序便可以同时执行。目前电脑市场上说的多核CPU，便是多核处理器，核越多，并行处理的程序越多，能大大的提高电脑运行的效率。
注意：单核处理器的计算机肯定是不能并行的处理多个任务的，只能是多个任务在单个CPU上并发运行。同理,线程也是一样的，从宏观角度上理解线程是并行运行的，但是从微观角度上分析却是串行运行的，即一个线程一个线程的去运行，当系统只有一个CPU时，线程会以某种顺序执行多个线程，我们把这种情况称之为线程调度。
2 线程与进程
程序：指令和数据的有序集合，本身没任何运行含义，是静态概念
进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。（进入内存中运行的程序，叫进程）
线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程
线程调度:
- 分时调度
所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。
- 抢占式调度
优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)；
Java使用的为抢占式调度。
多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高。
在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程、gc线程
main()线程称之为主线程，为系统的入口，用于执行整个程序
在一个进程中，如果开辟了多线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为的干预
对同一份资源操作时，会出现资源抢夺问题，需加入并发控制
线程会带来额外的开销，如cpu调度时间，并发控制开销
每个线程在自己的工作内存交互，内存控制不当会造成数据不一致
3 线程
3.1 Thread类
Java使用java.lang.Thread 类代表线程，所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。Java使用线程执行体来代表这段程序流。
构造方法：
- public Thread() :分配一个新的线程对象。
- public Thread(String name) :分配一个指定名字的新的线程对象。
- public Thread(Runnable target) :分配一个带有指定目标新的线程对象。
- public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定名字。
常用方法：
- public String getName() :获取当前线程名称。
- public void start() :导致此线程开始执行; Java虚拟机调用此线程的run方法。
- public void run() :此线程要执行的任务在此处定义代码。
- public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
- public static Thread currentThread() :返回对当前正在执行的线程对象的引用。
主线程
JVM执行main方法，main方法会进入到栈内存，JVM会找操作系统开辟一条 main方法通向CPU的执行路径，CPU就可以通过这个路径来执行main方法，而此路径就称为main(主)线程。
-
普通方法调用和多线程调用
3.2 创建线程
3.2.1 方式一：继承Thread类
Java中通过继承Thread类来创建并启动多线程的步骤如下：
- 定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。
- 创建Thread子类的实例，即创建了线程对象
- 调用线程对象的start()方法来启动该线程
- 启动线程后，不一定立即执行，由cpu调度安排(主线程与thread线程，穿插进行)
- 子类继承Thread类具有多线程的能力(Thread类实现类Runnable接口)
- 启动线程：子类对象.start()
- 不建议使用：避免OOP单继承局限性
public class MyThread extends Thread {
public MyThread(String name) {
super(name);
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(getName() + "正在执行！" + i);
}
}
}
public class DemoTest {
public static void main(String[] args) {
MyThread thread = new MyThread("新的线程");
thread.start();
for (int i = 0; i < 10; i++) {
System.out.println("main线程" + i);
}
}
}
3.2.2 方式二：实现Runnable接口
实现java.lang.Runnable接口，重写run()方法。（Thread类也实现了Runnable接口）
步骤：
- 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
- 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
- 调用线程对象的start()方法来启动线程。
- 实现Runnable具有多线程能力
- 启动线程：传入目标对象+Thread对象.start()
- 推荐：避免单继承局限性，方便同一个对象被多个线程使用
public class MyRunnable implements Runnable{
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.print(Thread.currentThread().getName()+ " " + i + ",");
}
}
}
public class DemoTest {
public static void main(String[] args) {
MyRunnable mr = new MyRunnable();
Thread tr = new Thread(mr, "小强");
Thread otr = new Thread(mr, "佩奇");
tr.start();
otr.start();
for (int i = 0; i < 10; i++) {
System.out.print("旺财" + i + ",");
}
}
}
/**
旺财0,旺财1,旺财2,旺财3,旺财4,旺财5,旺财6,旺财7,旺财8,旺财9,
佩奇 0,小强 0,佩奇 1,小强 1,佩奇 2,小强 2,佩奇 3,小强 3,佩奇 4,
小强 4,佩奇 5,小强 5,小强 6,小强 7,小强 8,小强 9,佩奇 6,佩奇 7,佩奇 8,佩奇 9,
*/
**所有的多线程代码都在run方法里面
tips:Runnable对象仅仅作为Thread对象的target，Runnable实现类里包含的run()方法仅作为线程执行体。而实际的线程对象依然是Thread实例，只是该Thread线程负责执行其target的run()方法。
3.2.3 方式三：匿名内部类方式实现线程创建
使用线程的内匿名内部类方式，可以方便的实现每个线程执行不同的线程任务操作。
使用匿名内部类的方式实现Runnable接口，重新Runnable接口中的run方法：
public class NoNameInnerClassThread {
public static void main(String[] args) {
Runnable runnable = new Runnable() {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("xiaoqinag" + i);
}
}
};
new Thread(runnable).start();
for (int i = 0; i < 20; i++) {
System.out.println("daqiang:"+i);
}
}
}
3.2.4 方式四：Lambda方式实现线程创建
public class LambdaThread {
public static void main(String[] args) {
new Thread(() -> {
for (int i = 0; i < 10; i++) {
System.out.println("xiaoqinag" + i);
}
}, "lambdaThread").start();
for (int i = 0; i < 20; i++) {
System.out.println("daqiang:"+i);
}
}
}
3.2.5 实现Callable接口
- 实现Callable接口
- 1.实现Callable接口，需要返回值类型
- 2.重写call方法,需要抛出异常
- 3.创建目标对象t1
- 4.创建执行服务:
ExecutorService ser = Executors.newFixedThreadPool(1); - 5.提交执行:
Future<Boolean> result1 = ser.submit(t1); - 6.获取结果:
boolean r1 = result1.get()
3.2.6 Thread和Runnable的区别
如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。
实现Runnable接口比继承Thread类所具有的优势：
-
适合多个相同的程序代码的线程去共享同一个资源。
-
可以避免java中的单继承的局限性。
-
增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
- 实现Runnable接口的方式，把设置线程任务和开启新线程进行分解（解耦）
- 实现类中重写run方法：用来设置线程的任务；
- 创建Thread类对象，调用start方法：用来开启新线程
-
线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。
扩充：在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都会启动一个JVM，每一个JVM其实在就是在操作系统中启动了一个进程。
3.3 多线程的原理
public class MyThread extends Thread{
/*
* 利用继承中的特点
* 将线程名称传递 进行设置
*/
public MyThread(String name){
super(name);
}
/*
* 重写run方法
* 定义线程要执行的代码
*/
public void run(){
for (int i = 0; i < 20; i++) {
//getName()方法 来自父亲
System.out.println(getName()+i);
}
}
}
public class Demo {
public static void main(String[] args) {
System.out.println("这里是main线程");
MyThread mt = new MyThread("小强");
mt.start();//开启了一个新的线程
for (int i = 0; i < 20; i++) {
System.out.println("旺财:"+i);
}
}
}
程序启动运行main时候，java虚拟机启动一个进程，主线程main在main()调用时候被创建。随着调用mt的对象的start方法，另外一个新的线程也启动了，这样，整个应用就在多线程下运行。2个线程抢占CPU的执行资源
多线程执行时，在栈内存中，其实每一个执行线程都有一片自己所属的栈内存空间
多个线程之间互不影响（在不同的栈空间）
3.4 守护(daemon)线程
- 线程分为用户线程和守护线程
- 虚拟机必须确保用户线程执行完毕
- 虚拟机不用等待守护线程执行完毕
- 用户线程结束，守护线程也会停止
- 用户线程变守护线程（setDaemon(true)，默认为false）
public class DaemonThread {
public static void main(String[] args) {
//守护线程
Thread god = new Thread(() -> {
while (true) {
System.out.println(Thread.currentThread().getName() + ":god...always");
}
}, "God thread");
god.setDaemon(true);
god.start();
//用户线程
new Thread(() -> {
for (int i = 0; i < 36500; i++) {
System.out.println(Thread.currentThread().getName() + ":live" + i);
}
System.out.println("======GOODBYE WORLD=====");
}, "You thread").start();
}
}
4 线程安全
4.1 线程安全
如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。
/** 模拟多窗口买票 */
public class Ticket implements Runnable {
private int ticket = 100;
@Override
public void run() {
while (true) {
if (ticket > 0) {
try {//模拟出票
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "正在卖：" + ticket--);
}
}
}
}
public static void main(String[] args) {
Ticket ticket = new Ticket();
Thread t1 = new Thread(ticket, "窗口1");
Thread t2 = new Thread(ticket, "窗口2");
Thread t3 = new Thread(ticket, "窗口3");
t1.start();
t2.start();
t3.start();
}
/**
...
窗口1正在卖：3
窗口2正在卖：2
窗口3正在卖：1
窗口1正在卖：0
窗口2正在卖：-1
*/
线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全。
4.2 线程同步
当使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。
要解决上述多线程并发访问一个资源的安全性问题，Java中提供了同步机制****(synchronized)来解决。
线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用
实现同步机制的三种方式：(同步条件：队列+锁)
- 同步代码块。
- 同步方法。
- 锁机制。
加锁后存在的问题：
- 一个线程持有锁会导致其他所有需要此锁的线程挂起
- 在多线程竞争下，加锁、释放锁，会导致比较多的上下文切换 和 调度延时，引起性能问题
- 如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问题
4.2.1 同步代码块
同步代码块： synchronized 关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。
格式:
synchronized(同步锁Obj){
//需要同步操作的代码
}
同步锁(同步监视器):
对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁.
- 锁对象obj 可以是任意类型，推荐使用共享资源作为同步监视器。
- 多个线程对象 要使用同一把锁。
注意:在任何时候,最多允许一个线程拥有同步锁,谁拿到锁就进入代码块,其他的线程只能在外等着(BLOCKED)。
public class Ticket implements Runnable {
private int ticket = 100;
Object obj = new Object();
@Override
public void run() {
while (true) {
synchronized (obj) {//锁
if (ticket > 0) {
try {//模拟出票
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "正在卖：" + ticket--);
}
}
}
}
}
4.2.2 同步方法
同步方法:使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。
格式
public synchronized void method(){
//可能会产生线程安全问题的代码
}
同步锁是谁?
- 对于非static方法,同步锁就是this。
- 对于static方法,我们使用当前方法所在类的字节码对象(类名.class)。
@Override
public void run() {
while (true) {
sellTicket();
}
}
/**
* 锁对象 是 谁调用这个方法 就是谁
* 隐含 锁对象 就是 this
*/
private synchronized void sellTicket() {
if (ticket > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "正在卖：" + ticket--);
}
}
4.2.3 锁机制Lock
java.util.concurrent.locks.Lock 机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作,同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。
Lock锁也称同步锁，加锁与释放锁方法化了，如下：
- public void lock() :加同步锁。
- public void unlock() :释放同步锁。(放在finally中进行)
public class LockThread implements Runnable {
Lock lock = new ReentrantLock();//ReentrantLock 实现了 Lock 接口
@Override
public void run() {
lock.lock();
try {
System.out.println(Thread.currentThread().getName());
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
4.2.4 synchronize && lock
- Lock是显式锁(手动开启和关闭锁)，synchronize是隐式锁，出了作用域自动释放
- Lock只有代码块锁，synchronize有代码块锁和方法锁
- 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好，并且具有更好的扩展性(提供更多子类)
- 优先使用顺序
- Lock > 同步代码块(已进入方法体，分配了相应资源) > 同步方法(在方法体外)
5 线程状态
5.1 线程状态概述
在API中java.lang.Thread.State 这个枚举中给出了六种线程状态
| 线程状态 | 导致状态发生条件 |
|---|---|
| NEW(新建) | 线程刚被创建，但是并未启动。还没调用start方法。 |
| Runnable(可运行) | 线程可以在java虚拟机中运行的状态，可能正在运行自己代码，也可能没有，这取决于操作系统处理器。 |
| Blocked(锁阻塞) | 当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。 |
| Waiting(无限等待) | 一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。 |
| Timed Waiting(计时等待) | 同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep 、Object.wait。 |
| Teminated(被终止) | 因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。 |
Timed Waiting：A thread that is waiting for another thread to perform an action for up to a specified waiting time is in this state.
- 进入 TIMED_WAITING 状态的一种常见情形是调用的 sleep 方法，单线程也可以调用，不一定非要有协作关系。
- 为了让其他线程有机会执行，可以将Thread.sleep()的调用放线程run()之内。这样能保证该线程执行过程中会睡眠
- sleep与锁无关，线程睡眠到期自动苏醒，并返回到Runnable（可运行）状态。
小提示：sleep()中指定的时间是线程不会运行的最短时间。因此，sleep()方法不能保证该线程睡眠到期后就开始立刻执行。
Blocked：A thread that is blocked waiting for a monitor lock is in this state.
- 受阻塞并且正在等待监视器锁的某一线程的线程状态。处于受阻塞状态的某一线程正在等待监视器锁，以便进入一个同步的块/方法；
- 线程A与线程B代码中使用同一锁，如果线程A获取到锁，线程A进入到Runnable状态，那么线程B就进入到Blocked锁阻塞状态。
Waiting ： A thread that is waiting indefinitely for another thread to perform a particular action is in this state.
- 一个正在无限期等待另一个线程执行一个特别的（唤醒）动作的线程处于这一状态。
public class WaitingDemo {
public static Object obj = new Object();
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
while (true) {
synchronized (obj) {
try {
System.out.println(Thread.currentThread().getName()
+ "=== 获取到锁对象，调用wait方法，进入waiting状态，释放锁对象");
obj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+ "=== 从waiting状态醒来，获取到锁对象，继续执行了");
}
}
}
},"等待线程").start();
new Thread(new Runnable() {
@Override
public void run() {
while (true) {
try {
System.out.println(Thread.currentThread().getName()
+ "------- 等待3秒钟");
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (obj) {
System.out.println(Thread.currentThread().getName()
+ "------ 获取到锁对象，调用notify方法，释放锁对象");
obj.notify();
}
}
}
},"唤醒线程").start();
}
}
/**
等待线程=== 获取到锁对象，调用wait方法，进入waiting状态，释放锁对象
唤醒线程------- 等待3秒钟
唤醒线程------ 获取到锁对象，调用notify方法，释放锁对象
唤醒线程------- 等待3秒钟
等待线程=== 从waiting状态醒来，获取到锁对象，继续执行了
等待线程=== 获取到锁对象，调用wait方法，进入waiting状态，释放锁对象
唤醒线程------ 获取到锁对象，调用notify方法，释放锁对象
唤醒线程------- 等待3秒钟
等待线程=== 从waiting状态醒来，获取到锁对象，继续执行了
等待线程=== 获取到锁对象，调用wait方法，进入waiting状态，释放锁对象
唤醒线程------ 获取到锁对象，调用notify方法，释放锁对象
唤醒线程------- 等待3秒钟
等待线程=== 从waiting状态醒来，获取到锁对象，继续执行了
等待线程=== 获取到锁对象，调用wait方法，进入waiting状态，释放锁对象
...
*/
- 一个调用了某个对象的 Object.wait 方法的线程会等待另一个线程调用此对象的Object.notify()方法 或 Object.notifyAll()方法。其实waiting状态并不是一个线程的操作，它体现的是多个线程间的通信，可以理解为多个线程之间的协作关系，多个线程会争取锁，同时相互之间又存在协作关系
- 当多个线程协作时，比如A，B线程，如果A线程在Runnable（可运行）状态中调用了wait()方法那么A线程就进入了Waiting（无限等待）状态，同时失去了同步锁。假如这个时候B线程获取到了同步锁，在运行状态中调用了notify()方法，那么就会将无限等待的A线程唤醒。注意是唤醒，如果获取到锁对象，那么A线程唤醒后就进入Runnable（可运行）状态；如果没有获取锁对象，那么就进入到Blocked（锁阻塞状态）。
线程个状态之间的转化：
public class StateThread {
public static void main(String[] args) {
Thread thread = new Thread(() -> {
for (int i = 0; i < 10; i++) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("AAAAAAAAAAAAAAAAAA");
});
//NEW
Thread.State state = thread.getState();
System.out.println(state);
thread.start();
//RUNNABLE
state = thread.getState();
System.out.println(state);
while (state != Thread.State.TERMINATED) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
//TIMED_WAITING
System.out.println(state);
state = thread.getState();
}
//TERMINATED
System.out.println(state);
}
}
5.2 线程的停止
- 线程运行完后自己停止
- 使用标志位控制线程停止(推荐)
- 不推荐jdk提供的stop、destroy方法(已废弃)
public class StopThread implements Runnable {
//标志位
private boolean flag = true;
@Override
public void run() {
while (flag) {
System.out.println("thread....run...");
}
}
//对外提供改变标志位方法
public void stop() {
this.flag = false;
}
public static void main(String[] args) {
StopThread target = new StopThread();
new Thread(target).start();
for (int i = 0; i < 1000; i++) {
System.out.println("main.....run..." + i);
if (i == 988) {
target.stop();
System.out.println("thread....stop...");
}
}
}
}
5.3 线程休眠
- sleep(时间) 指定当前线程阻塞的毫秒数
- sleep存在异常 InterruptException
- sleep时间到达后线程进入就绪状态
- sleep模拟网络延时(放大问题发生的可能性)、倒计时等
- 每一个对象都有一个锁，sleep不会释放锁
public class SleepThread implements Runnable {
private int ticketNum = 10;
@Override
public void run() {
while (true) {
if (ticketNum <= 0) {
break;
}
try {
//模拟网络延时
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "拿到了第" + ticketNum-- + "张票");
}
}
public static void main(String[] args) {
TestTicketThread ticket = new TestTicketThread();
new Thread(ticket, "AA").start();
new Thread(ticket, "BB").start();
new Thread(ticket, "CC").start();
oneMinDown();
}
//倒计时
public static void oneMinDown() {
int num = 60;
for (int i = num; i > 0; i--) {
System.out.println(num--);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
5.4 线程礼让
- 礼让线程yield，让当前正在执行的线程暂停，但不阻塞
- 将线程从运行状态转为就绪状态
- 让cpu重新调度，礼让不一定成功
public class YieldThread {
public static void main(String[] args) {
Runnable target = ()->{
System.out.println(Thread.currentThread().getName()+"-->start");
Thread.yield();
System.out.println(Thread.currentThread().getName()+"-->end");
};
new Thread(target,"AA").start();
new Thread(target,"BB").start();
}
}
/*
礼让成功 礼让失败
AA-->start AA-->start
BB-->start AA-->end
AA-->end BB-->start
BB-->end BB-->end
*/
5.5 线程强制执行
- join 合并线程，阻塞其他线程，待该线程执行完之后，再执行其他线程
- 类似插队
public class JoinThread {
public static void main(String[] args) {
Thread thread = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
System.out.println("thread...."+i);
}
});
thread.start();
for (int i = 0; i < 500; i++) {
if (i == 200) {
try {
//插队
thread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("main...." + i);
}
}
}
5.6 线程优先级
- Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行
- 线程优先级用数字表示，范围1~10
- Thread.MIN_PRIORITY = 1;
- Thread.MAX_PRIORITY = 10;
- Thread.NORM_PRIORITY = 5;
- getPriority() 获取优先级
- setPriority(int xxx) 设置优先级 优先级的设置在start()之前
- 优先级高低意味着获得优先调度概率的高低，最终的调度还是看cpu
6 等待唤醒机制
6.1 线程间通信
概念：多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同。
- 为何要处理线程之间的通讯？
让多线程在访问同一份资源时按照一定的规律进行。
- 如何保证线程间通信有效利用资源：
多个线程在处理同一个资源，并且任务不同时，需要线程通信来帮助解决线程之间对同一个变量的使用或操作，避免对同一共享变量的争夺————等待唤醒机制
6.2 等待唤醒机制
等待唤醒机制
- 是多个线程间的一种协作机制
- 在一个线程进行了规定操作后，就进入等待状态（wait()）， 等待其他线程执行完他们的指定代码过后 再将其唤醒（notify()）;在有多个线程进行等待时， 如果需要，可以使用 notifyAll()来唤醒所有的等待线程。
- wait/notify 就是线程间的一种协作机制。
等待唤醒中的方法
- wait：线程不再活动，不再参与调度，进入 wait set 中，因此不会浪费 CPU 资源，也不会去竞争锁了，这时的线程状态即是 WAITING。它还要等着别的线程执行一个特别的动作，也即是“通知（notify）”在这个对象上等待的线程从wait set 中释放出来，重新进入到调度队列（ready queue）中
- wait(long timeout)：等待指定的毫秒数
- notify：则选取所通知对象的 wait set 中的一个线程释放；例如，餐馆有空位后，等候就餐最久的顾客最先入座。
- notifyAll：则释放所通知对象的 wait set 上的全部线程，优先级别高的线程优先调度。
注意：
哪怕只通知了一个等待的线程，被通知线程也不能立即恢复执行，因为它当初中断的地方是在同步块内，而此刻它已经不持有锁，所以她需要再次尝试去获取锁（很可能面临其它线程的竞争），成功后才能在当初调用 wait 方法之后的地方恢复执行。
总结如下：
- 如果能获取锁，线程就从 WAITING 状态变成 RUNNABLE 状态；
- 否则，从 wait set 出来，又进入 entry set，线程就从 WAITING 状态又变成 BLOCKED 状态
调用wait和notify方法需要注意的细节
- wait方法与notify方法必须要由同一个锁对象调用。因为：对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。
- wait方法与notify方法是属于Object类的方法的。因为：锁对象可以是任意对象，而任意对象的所属类都是继承了Object类的。
- wait方法与notify方法必须要在同步代码块或者是同步函数中使用，否则会抛出异常IIlegalMonitorStateException。因为：必须要通过锁对象调用这2个方法。
6.3 生产者与消费者问题
等待唤醒机制其实就是经典的“生产者与消费者”的问题。
生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件
- 对于生产者，没有生产产品之前，要通知消费者等待。而生产产品之后，又要马上通知消费者消费
- 对于消费者，在消费之后，要通知生产者已经结束消费，需要生产新的产品以供消费
解决方法：线程同步+线程通讯
6.3.1 信号灯法（通过标志位）
- 包子铺线程生产包子，吃货线程消费包子。当包子没有时（包子状态为false），吃货线程等待，包子铺线程生产包子（即包子状态为true），并通知吃货线程（解除吃货的等待状态）,因为已经有包子了，那么包子铺线程进入等待状态。接下来，吃货线程能否进一步执行则取决于锁的获取情况。如果吃货获取到锁，那么就执行吃包子动作，包子吃完（包子状态为false），并通知包子铺线程（解除包子铺的等待状态）,吃货线程进入等待。包子铺线程能否进一步执行则取决于锁的获取情况。
//资源
public class Baozi {
private String pier;
private String xianer;
private boolean flag = false;//包子资源，是否存在
public Baozi() {
}
public Baozi(String pier, String xianer) {
this.pier = pier;
this.xianer = xianer;
}
public String getPier() {
return pier;
}
public void setPier(String pier) {
this.pier = pier;
}
public String getXianer() {
return xianer;
}
public void setXianer(String xianer) {
this.xianer = xianer;
}
public boolean isFlag() {
return flag;
}
public void setFlag(boolean flag) {
this.flag = flag;
}
}
//消费者
public class ChiHuo extends Thread {
private Baozi bz;
public ChiHuo(String name, Baozi bz) {
super(name);
this.bz = bz;
}
@Override
public void run() {
while (true) {
synchronized (bz) {
if (bz.isFlag() == false) {
try {
bz.wait();//吃货等待
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("吃货正在吃" + bz.getPier() + bz.getXianer() + "包子！");
System.out.println("包子吃完了！");
bz.setFlag(false);
bz.notify();//唤醒包子铺
}
}
}
}
//生产者
public class BaoZiPu extends Thread {
private Baozi bz;
public BaoZiPu(String name, Baozi bz) {
super(name);
this.bz = bz;
}
@Override
public void run() {
int count = 0;
while (true) {
synchronized (bz) {
if (bz.isFlag()) {
try {
bz.wait();//包子铺停止生产
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("包子铺开始做包子");
if (count % 2 == 0) {
bz.setPier("冰皮");
bz.setXianer("五仁");
} else {
bz.setPier("薄皮");
bz.setXianer("牛肉大葱");
}
count++;
bz.setFlag(true);
System.out.println("包子造好了：" + bz.getPier() + bz.getXianer());
System.out.println("吃货来吃包子吧");
bz.notify();//唤醒吃货吃包子
}
}
}
}
public class BaoZiTest {
public static void main(String[] args) {
Baozi bz = new Baozi();
BaoZiPu bzp = new BaoZiPu("包子铺", bz);
ChiHuo ch = new ChiHuo("吃货", bz);
bzp.start();
ch.start();
}
}
/*
包子铺开始做包子
包子造好了：冰皮五仁
吃货来吃包子吧
吃货正在吃冰皮五仁包子！
包子吃完了！
包子铺开始做包子
包子造好了：薄皮牛肉大葱
吃货来吃包子吧
吃货正在吃薄皮牛肉大葱包子！
包子吃完了！
包子铺开始做包子
*/
6.3.2 管程法
-
生产者：负责生产数据的模块(可能是方法、对象、线程、进程)
-
消费者：负责处理数据的模块(可能是方法、对象、线程、进程)
-
缓冲区：消费者不能直接使用生产者的数据，他们之间有个“缓冲区”，生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据
//生产者、消费者、产品、容器
public class PCThread {
public static void main(String[] args) {
SynContainer container = new SynContainer();
new Provider(container).start();
new Consumer(container).start();
}
}
//生产者
class Provider extends Thread {
SynContainer container;
public Provider(SynContainer container) {
this.container = container;
}
@Override
public void run() {
for (int i = 1; i <= 100; i++) {
System.out.println("生产者生产第" + i + "只鸡");
container.push(new Chicken(i));
}
}
}
//消费者
class Consumer extends Thread {
SynContainer container;
public Consumer(SynContainer container) {
this.container = container;
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("消费者消费第" + container.pop().id + "只鸡");
}
}
}
//资源 鸡
class Chicken {
int id;
public Chicken(int id) {
this.id = id;
}
}
//缓冲区 容器
class SynContainer {
//容器大小
Chicken[] chickens = new Chicken[10];
//容器计数器
int count;
//生产者放入产品
public synchronized void push(Chicken chicken) {
//容器满了，生产者停止生产，等待消费者消费
if (count == chickens.length) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//没满，则放入产品
chickens[count] = chicken;
count++;
//通知消费者消费
this.notifyAll();
}
//消费者消费产品
public synchronized Chicken pop() {
//判断能否消费
if (count == 0) {
//消费者等待生产者生产
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//可以消费
count--;
Chicken chicken = chickens[count];
//吃完了通知生产者生产
this.notifyAll();
return chicken;
}
}
7 线程池
7.1 概述
线程池：其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。
- 降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
- 提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
- 提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。
- corePoolSize：核心池的大小
- maximumPoolSize：最大线程数
- keepAliveTime：线程没有任务时最多保持多长时间后会终止
7.2 线程池的使用
-
Java里面线程池的顶级接口是java.util.concurrent.Executor ，但是严格意义上讲Executor 并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是java.util.concurrent.ExecutorService 。
-
在java.util.concurrent.Executors 线程工厂类里面提供了一些静态工厂，生成一些常用的线程池。官方建议使用Executors工程类来创建线程池对象。
- public static ExecutorService newFixedThreadPool(int nThreads) ：返回线程池对象。(创建的是有界线程池,也就是池中的线程个数可以指定最大数量)
-
使用线程池对象
-
void execute(Runnable command)：执行任务/命令，没有返回值，一般用来执行Runnable
-
<T> Future<T> submit(Callable<T> task)：执行任务，有返回值，一般用来执行Callable- Future接口：用来记录线程任务执行完毕后产生的结果。线程池创建与使用。
-
void shutdown()：关闭连接池
-
-
使用线程池中线程对象的步骤：
- 创建线程池对象。
- 创建Runnable接口子类对象。(task)
- 提交Runnable接口子类对象。(take task)
- 关闭线程池(一般不做)。
public class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println("我要一个教练");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("教练来了： " + Thread.currentThread().getName());
System.out.println("教我游泳,交完后，教练回到了游泳池");
}
}
public class ThreadPoolDemo {
public static void main(String[] args) {
// 创建线程池对象
ExecutorService service = Executors.newFixedThreadPool(2);//包含2个线程对象
// 创建Runnable实例对象
MyRunnable r = new MyRunnable();
//自己创建线程对象的方式
// Thread t = new Thread(r);
// t.start(); ‐‐‐> 调用MyRunnable中的run()
// 从线程池中获取线程对象,然后调用MyRunnable中的run()
service.submit(r);
// 再获取个线程对象，调用MyRunnable中的run()
service.submit(r);
service.submit(r);
// 注意：submit方法调用结束后，程序并不终止，是因为线程池控制了线程的关闭。
// 将使用完的线程又归还到了线程池中
// 关闭线程池
//service.shutdown();
}
}
