文章目录
- 一、线程概述
- 1. 线程和进程
- 2. 多线程的优势
- 二、线程的创建和启动
- 1. 继承 Thread 类创建线程类
- 2. 实现 Runnable 接口创建线程类
- 3. 使用 Callable 和 Future 创建线程
- 4. 创建线程的三种方式对比
- 三、线程的生命周期
- 1. 新建和就绪状态
- 2. 运行和阻塞状态
- 3. 线程死亡
- 四、控制线程
- 1. join 线程
- 2. 后台线程
- 3. 线程睡眠：sleep
- 4. 线程让步：yield
- 5. 改变线程的优先级
- 五、线程同步
- 1. 线程安全问题
- 2. 同步代码块
- 3. 同步方法
- 4. 释放同步监视器的锁定
- 5. 同步锁（Lock）
- 6. 死锁
- 六、线程通信
- 1. 传统的线程通信
- 2. 使用 Condition 控制线程通信
- 3. 使用阻塞队列（BlockingQueue）控制线程通信
- 七、线程组和未处理的异常
- 八、线程池
- 1. Java8 改进的线程池
- 2. Java8 增强的 ForkJoinPool
- 九、线程相关类
- 1. ThreadLocal 类
- 2. 包装线程不安全的集合
- 3. 线程安全的集合类
一、线程概述
1. 线程和进程
- 进程：是处于运行过程中的程序，并且具有一定的独立功能，进程是系统进行资源分配和调度的一个独立单位；
- 一般而言，进程包含如下三个特征：
①独立性：进程是系统中独立存在的实体，可以拥有自己的独立资源；
②动态性：进程与程序的最大区别是：程序是静态的指令集合，进程是一个正在系统中活动的指令集合；
③并发性：多个进程可以在单个处理器上并发执行，之间不会相互影响； - 注意：并行性是指在同一时刻，有多条指令在多个处理器上同时执行；并发性是指在同一时刻只能有一条指令执行，但多个进程指令可以被快速轮换执行，使得宏观上有多个进程同时执行的效果；
- 多线程扩展了多进程的概念，使得同一个进程可以同时并发处理多个任务；
- 线程是进程的执行单元，线程在程序中是独立的、并发的执行流；
- 线程是进程的组成部分，一个进程可以有多个线程，一个线程必须有一个父进程；
- 线程可以拥有自己的堆栈、自己的局部变量，但不拥有系统资源，它与父进程的其他线程共享该进程拥有的全部资源；
- 线程的执行时抢占式的，当前运行的线程在任何时候都会被挂起，以便另一个线程可以运行；
- 一个线程可以创建和撤销另一个线程，同一个进程中的线程之间可以并发执行；
- 小结：操作系统可以同时执行多个任务，每个任务就是进程；进程可以同时执行多个任务，每个任务就是线程；
2. 多线程的优势
- 多线程编程具有以下优势：
①进程之间不能共享内存，但线程之间共享内存非常容易；
②系统创建进程时需要为该进程重新分配系统资源，但创建线程代价小得多，因此使用多线程实现任务的并发效率高；
③Java 语言内置了多线程功能支持，简化了多线程编程；
二、线程的创建和启动
1. 继承 Thread 类创建线程类
- 通过继承 Thread 类来创建并启动多线程的步骤：
①定义 Thread 类的子类，并重写该类的 run() 方法；（把 run() 方法称为线程执行体）
②创建 Thread 子类的实例，即创建了线程对象；
③调用线程对象的 start() 方法来启动线程； - 下面程序示范了通过继承 Thread 类来创建并启动多线程：
public class FirstThread extends Thread {
private int i;
//重写 run() 方法，run() 方法的执行体就是线程的执行体
public void run(){
for ( ; i < 100; i++){
//当线程类继承 Thread 类时，直接使用 this 即可获取当前线程；
//Thread 对象的 getName() 返回当前线程的名字；
System.out.println(getName() + " " + i);
}
}
public static void main(String[] args) {
for (int i = 0; i < 100; i++){
System.out.println(Thread.currentThread().getName() + " " + i);
if (i == 20){
//创建并启动第一个线程
new FirstThread().start();
//创建并启动第二个线程
new FirstThread().start();
}
}
}
}- 注意：使用继承 Thread 类的方法来创建线程类时，多个线程之间无法共享线程类的实例变量；
2. 实现 Runnable 接口创建线程类
- 实现 Runnable 接口来创建并启动多线程的步骤：
①定义 Runnable 接口的实现类，并重写该接口的 run() 方法，该 run() 方法的方法体同样是该线程的线程执行体；
②创建 Runnable 实现类的实例，并以此实例作为 Thread 的 target 来创建 Thread 对象，该 Thread 对象才是真正的线程对象；
③调用线程对象的 start() 方法来启动该线程； - 通过实现 Runnable 接口来创建并启动多线程：
public class SecondThread implements Runnable{
private int i;
@Override
public void run() {
for ( ; i < 100; i++){
//当线程类实现 Runnable 接口时，
//如果想获取当前线程，只能用 Thread。currentThread() 方法
System.out.println(Thread.currentThread().getName() + " " + i);
}
}
public static void main(String[] args) {
for (int i = 0; i < 100; i++){
System.out.println(Thread.currentThread().getName() + " " + i);
if (i == 20){
SecondThread st = new SecondThread();
new Thread(st, "新线程1").start();
new Thread(st, "新线程2").start();
}
}
}
}3. 使用 Callable 和 Future 创建线程
- Callable 接口提供了一个 call() 方法可以作为线程执行体，但 call() 方法比 run() 方法功能更加强大；
call() 方法可以有返回值；call() 方法可以声明抛出异常； - call() 方法 不是直接调用，它是作为线程执行体被调用的；
- 创建并启动有返回值的线程的步骤：
①创建 Callable 接口的实现类，并实现 call() 方法，在创建 Callable 实现类的实例；
②使用 FutureTask 类来包装 Callable 对象，该 FutureTask 对象封装了该 Callable 对象的 call() 方法的返回值；
③使用 FutureTask 对象作为 Thread 对象的 target 创建并启动新线程；
④调用 FutureTask 对象的 get() 方法来获得子线程执行结束后的返回值； - 通过实现 Callable 接口来实现线程类：
public class ThridThread {
public static void main(String[] args) {
//创建 Callable 对象
ThridThread rt = new ThridThread();
//使用 FutureTask 来包装 Callable 对象
FutureTask<Integer> task = new FutureTask<Integer>((Callable<Integer>) ()->{
int i = 0;
for ( ; i < 100; i++){
System.out.println(Thread.currentThread().getName() + " " + i);
}
//call() 方法可以有返回值
return i;
});
for (int i = 0; i < 100; i++){
System.out.println(Thread.currentThread().getName() + " " + i);
if (i == 20){
//实质还是以 Callable 对象来创建并启动线程的
new Thread(task, "有返回值的线程").start();
}
}
try {
//获取线程的返回值
System.out.println("子线程的返回值：" + task.get());
}
catch (Exception e){
e.printStackTrace();
}
}
}4. 创建线程的三种方式对比
Thread | Runnable & Callable |
/ | 两种实现方式基本相同，可以归为一类；（Callable 接口里定义的方法有返回值，可以声明抛出异常） |
优势：编写简单如果需要访问当前线程，不需要使用 Thread.currentThread() 方法没直接使用 this 即可获得当前线程； | 优势：①线程类只是实现了Runnable 接口或 Callable 接口，还可以继承其他类；②多个线程可以共享一个 target 对象，所以非常适合多个相同线程来处理同一份资源的情况，将CPU、代码、数据分开，较好的体现了面向对象的思想； |
劣势：因为线程已经继承了 Thread 类，就不能继承其他父类； | 编程稍微复杂，如果需要访问当前线程，则必须使用 Thread.currentThread()方法； |
三、线程的生命周期
- 线程的生命周期：
新建、就绪、运行、阻塞、死亡；
1. 新建和就绪状态
- 新建状态：用 new 创建了一个线程；
- 就绪状态：线程调用了 start() 方法之后；
- 启动线程的正确方法是调用 Thread 对象的 start() 方法，而不是直接调用 run() 方法，否则就变成单线程程序了；
- 注意：调用了线程的 run() 方法之后，该线程已不再处于新建状态，不要再次调用线程对象的 start() 方法；
- 只能对处于新建状态的线程调用 start() 方法，且只能调用一次；
2. 运行和阻塞状态
- 运行状态：如果处于就绪状态的线程获得了 CPU，开始执行 run() 方法的线程执行体，则该线程处于运行状态；
- 阻塞状态：发生如下情况时，会进入阻塞状态
①线程调用 sleep() 方法主动放弃所占用的处理器资源；
②线程调用了一个阻塞式 IO 方法，在该方法返回之前，该线程被阻塞；
③线程试图获得一个同步监视器，但该同步监视器正被其他线程所持有；
④线程正在等待某个通知；
⑤程序调用了线程的 suspend() 方法将该线程挂起；但这个方法容易导致死锁，应该尽量避免； - 被阻塞的线程会在合适的时候重新进入就绪状态；
- 针对上面的特殊情况，当发生如下特定情况时，可以解除上面的阻塞，让该线程重新进入就绪状态：
①调用 sleep() 方法的线程经过了指定时间；
②线程调用的阻塞式 IO 方法已经返回；
③线程成功的获得了试图取得的同步监视器；
④线程正在等待某个通知时，其他线程发出了一个通知；
⑤处于挂起状态的线程被调用了 resume() 恢复方法；
3. 线程死亡
- 线程会以下面三种方式结束，结束后就处于死亡状态：
①run() 或 call() 方法执行完成，线程正常结束；
②线程抛出一个未捕获的 Exception 或 Error；
③直接调用该线程的 stop() 方法来结束该线程；（容易导致死锁，通常不推荐）；
四、控制线程
1. join 线程
- Thread 提供了一个线程等待另一个线程完成的方法——join() 方法；
- 当在某个程序执行流中调用其他线程的 join() 方法时，调用线程将被阻塞，直到被 join() 方法加入的 join 线程执行完为止；
public class ThreadJoin extends Thread{
@Override
public void run() {
for (int i = 0; i < 100; i++){
System.out.println(getName() + ":" + i);
}
}
}public class ThreadJoinDemo {
public static void main(String[] args) {
ThreadJoin s1 = new ThreadJoin();
ThreadJoin s2 = new ThreadJoin();
ThreadJoin s3 = new ThreadJoin();
s1.setName("康熙");
s2.setName("四阿哥");
s3.setName("八阿哥");
s1.start();
try {
s1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
s2.start();
s3.start();
}
}2. 后台线程
- 后台线程：是在后台运行的，任务是为其他的线程提供服务；
- 后台线程有个特征：如果所有的前台线程都死亡，后台线程会自动死亡；
- 调用 Thread 对象的 setDaemon(true) 方法可以将指定线程设置成后台线程；setDaemon(true) 方法必须在 start() 方法之前调用；
public class ThreadDaemon extends Thread{
@Override
public void run() {
for (int i = 0; i < 100; i++){
System.out.println(getName() + ":" + i);
}
}
}/**
* setDaemon() 方法
* 将此线程标记为守护线程，
* 当运行的线程都是守护线程时，Java虚拟机将退出
*/
public class ThreadDaemonDemo {
public static void main(String[] args) {
ThreadDaemon s1 = new ThreadDaemon();
ThreadDaemon s2 = new ThreadDaemon();
s1.setName("关羽");
s2.setName("张飞");
//设置主线程为 刘备
Thread.currentThread().setName("刘备");
//设置守护线程
s1.setDaemon(true);
s1.setDaemon(true);
s1.start();
s2.start();
for (int i = 0; i < 10; i++){
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}3. 线程睡眠：sleep
- 如果需要让当前正在执行的线程暂停一段时间，并进入阻塞状态，则可以通过调用 Thread 类的静态 sleep() 方法来实现；
public class ThreadSleep extends Thread{
@Override
public void run() {
for (int i = 0; i < 100; i++){
System.out.println(getName() + ":" + i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}/**
* sleep 使当前正在执行的线程停留（暂停执行）指定的毫秒级
*/
public class ThreadSleepDemo {
public static void main(String[] args) {
ThreadSleep s1 = new ThreadSleep();
ThreadSleep s2 = new ThreadSleep();
ThreadSleep s3 = new ThreadSleep();
s1.setName("曹操");
s2.setName("刘备");
s3.setName("孙权");
s1.start();
s2.start();
s3.start();
}
}4. 线程让步：yield
- yield() 方法与 sleep() 方法相似，它也可以让当前正在执行的线程暂停，但不会阻塞，只是转入就绪状态；
- 当某个线程调用了 yield() 方法暂停之后，只有优先级与当前线程相同，或者优先级比当前线程高的 处于就绪状态的线程 才会获得执行的机会；
5. 改变线程的优先级
- 每个线程默认的优先级都与创建它的父线程的优先级相同，默认情况下，main 线程具有普通优先级；
- 可以使用 Thread 类的 setPriority() 方法来改变优先级；
五、线程同步
1. 线程安全问题
- 售票案例数据安全问题：
①同一张票被多个窗口售出；
②剩余的票出现负数； - 售票案例为什么会出现数据安全问题？
①是否是多线程环境；
②是否有共享数据；
③是否有多条语句操作共享数据； - 如何解决多线程安全问题？
基本思想：让程序没有安全问题的环境； - 怎么实现解决安全问题？
①把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可；
②如何锁起来：Java 提供了同步代码块的方式来解决；
2. 同步代码块
- 锁多条语句操作共享数据，可以使用同步代码块实现；
- synchronized(任意对象)：相当于给代码加锁，任意对象就可以看成一把锁；
- 括号里的 obj 就是 “同步监视器”
//不能在括号里 new Object()
//括号里的 obj 就是 “同步监视器”
private Object obj = new Object();
synchronized(obj){
多条语句操作共享数据
}- 同步的优缺点：
①优点：解决了多线程的数据安全问题；
②缺点：当线程很多时，因为每个线程都会去判断同步上的锁，这是很好非自愿的，无形中会降低运行的效率；
3. 同步方法
- 同步方法就是使用 synchronized 关键字来修饰某个方法，则该方法称为同步方法；同步方法的锁对象是：this；
修饰符 synchronized 返回值类型 方法名(方法参数){
}- 同步静态方法：同步静态方法的锁对象是：类名.class；
修饰符 static synchronized 返回值类型 方法名(方法参数){
}- 对于 synchronized 修饰的实例方法，无需显示指定同步监视器，同步方法的同步监视器是 this，也就是调用该方法的对象；
- 通过使用同步方法可以非常方便的实现线程安全的类，线程安全的类具有如下特征：
①该类的对象可以被多个线程安全的访问；
②每个线程调用该对象的任意方法之后都将得到正确的结果；
③每个线程调用该对象的任意方法之后，该对象状态依然保持合理状态； - synchronized 关键字可以修饰方法，可以修饰代码块，但不能修饰构造器、成员变量等；
4. 释放同步监视器的锁定
5. 同步锁（Lock）
- Lock 实现提供了比使用 synchronized 方法和语句可以获得更广泛的锁定操作；
- Lock 是接口，不能直接实例化，这里采用它的实现类 ReentrantLock 来实例化；
try{
lo.lock();
//多条语句操作共享数据代码
}finally{
lo.unlock();
}6. 死锁
- 当两个线程互相等待对方释放同步监视器时就会发生死锁；
- 一旦出现死锁，整个程序既不会发生任何异常，也不会给任何提示，只是所有线程都处于阻塞状态，无法继续；
六、线程通信
1. 传统的线程通信
2. 使用 Condition 控制线程通信
3. 使用阻塞队列（BlockingQueue）控制线程通信
七、线程组和未处理的异常
- Java 使用 ThreadGroup 来表示线程组，它可以对一批线程进行分类管理，Java 允许程序直接对线程组进行控制；
八、线程池
- 使用线程池可以很好的提高性能，尤其是当程序中需要创建大量生存期很短暂的线程时；
- 使用线程池可以有效地控制系统中并发线程的数量；
1. Java8 改进的线程池
2. Java8 增强的 ForkJoinPool
九、线程相关类
1. ThreadLocal 类
2. 包装线程不安全的集合
3. 线程安全的集合类
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
