本文详细讲解了程序、进程、线程的区别，探讨了单核CPU与多核CPU的并行与并发概念，阐述了多线程的需求、优点和使用场景。涵盖线程创建（包括Thread类、Runnable接口和Callable接口）、线程池、调度、优先级、同步机制、死锁及通信方法，是Java并发编程的全面指南。
区分几个概念
程序
是含有指令和数据的文件，被存储在磁盘或其他的数据存储设备中，也就是说程序是静态的代码。
进程
是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。在 Java 中，当我们启动 main 函数时其实就是启动了一个 JVM 的进程，而 main 函数所在的线程就是这个进程中的一个线程，也称主线程。
线程
线程与进程相似，但线程是一个比进程更小的执行单位。一个进程在其执行的过程中可以产生多个线程。与进程不同的是同类的多个线程共享进程的堆和方法区资源，但每个线程有自己的程序计数器、虚拟机栈和本地方法栈，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多，也正因为如此，线程也被称为轻量级进程。
单核CPU和多核CPU
并行和并发
- 并发：同一时间段，多个任务都在执行 (单位时间内不一定同时执行)；
- 并行：单位时间内，多个任务同时执行。
为何需要多线程？其优点有哪些？
- 提高应用程序的响应。
- 提高计算机系统CPU的利用率。
- 改善程序结构。
什么时候需要用到多线程？
- 程序需要同时执行两个或多个任务。
- 程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。
- 需要一些后台运行的程序时。
线程的创建
Thread类
JVM允许程序运行多个线程，它通过java.lang.Thread类来体现。
Thread类的特性
- 每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体。
- 通过该Thread对象的start()方法来启动这个线程，而非直接调用run()。
Thread类的构造器
- Thread() ：创建新的Thread对象。
- Thread(String threadname)：创建线程并指定线程实例名。
- Thread(Runnable target) ：指定创建线程的目标对象，它实现了Runnable接口中的run方法。
- Thread(Runnable target, String name) ：创建新的Thread对象。
Thread类的有关方法
- void start()： 启动线程，并执行对象的run()方法。
- run()：线程在被调度时执行的操作。
- String getName()：返回线程的名称。
- void setName(String name)：设置该线程名称。
- static Thread currentThread()：返回当前线程。在Thread子类中就是this，通常用于主线程和Runnable实现类。
- static void yield()：线程让步。暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程，若队列中没有同优先级的线程，忽略此方法。
- join()：当某个程序执行流中调用其他线程的 join() 方法时，调用线程将被阻塞，直到 join() 方法加入的 join 线程执行完为止。注意低优先级的线程也可以获得执行。
- static void sleep(long millis) ：(指定时间:毫秒)，令当前活动线程在指定时间段内放弃对CPU控制，使其他线程有机会被执行，时间到后重排队。抛出InterruptedException异常。
- stop()：强制线程生命期结束，已过时，不推荐使用。
- boolean isAlive()：返回boolean，判断线程是否还活着。
- 线程状态转换如下图：
线程创建有几种方式？
继承Thread类的方式
【步骤】：
- 定义子类继承Thread类。
- 子类中重写Thread类中的run方法。
- 创建Thread子类对象，即创建了线程对象。
- 调用线程对象start方法：启动线程，调用run方法。
【实例】：
class MyThread extends Thread{
public MyThread(){
super();
}
@Override
public void run() {
for(int i = 0;i < 10;i++){
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
public class ExtendThreadLen {
public static void main(String[] args){
MyThread myThread = new MyThread();
myThread.setName("myThread");
myThread.start();
}
}
【注意点】：
- 如果自己手动调用run()方法，那么就只是普通方法，没有启动多线程模式。
- run()方法由JVM调用，什么时候调用，执行的过程控制都有操作系统的CPU调度决定。
- 想要启动多线程，必须调用start方法。
- 一个线程对象只能调用一次start()方法启动，如果重复调用了，则将抛出异常“IllegalThreadStateException”。
实现Runnable接口的方式
【步骤】：
- 定义子类，实现Runnable接口。
- 子类中重写Runnable接口中的run方法。
- 通过Thread类含参构造器创建线程对象。
- 将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中。
- 调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法。
【实例】：
class MyThread1 implements Runnable{
private int j = 100;
@Override
public void run() {
while (true){
if(j > 0){
System.out.println(Thread.currentThread().getName() + ":" + j);
j--;
}else {
break;
}
}
}
}
public class ImplementRunnableLen {
public static void main(String[] args){
MyThread1 myThread1 = new MyThread1();
Thread thread = new Thread(myThread1);
thread.start();
Thread thread1 = new Thread(myThread1);
thread1.start();
}
}
实现Callable接口
【步骤】：
- 创建一个实现Callable接口的实现类。
- 重写call()，将此线程需要实现的操作声明在call方法中。
- 创建Callable接口实现类的对象。
- 将此Callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask对象。
- 将FutureTask对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start方法。
- 获取Callable的call方法的返回值。
【实例】：
class MyThread2 implements Callable<Integer>{
private int num = 0;
private int i = 100;
@Override
public Integer call() throws Exception {
while (true){
if(i > 0){
Thread.sleep(100);
System.out.println(Thread.currentThread().getName() + ":" + i);
num += i;
i--;
}else {
break;
}
}
return num;
}
}
public class ImplementCallableLen {
public static void main(String[] args){
MyThread2 myThread2 = new MyThread2();
FutureTask<Integer> futureTask = new FutureTask<>(myThread2);
new Thread(futureTask).start();
int num = 0;
try {
num = futureTask.get();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
System.out.println("结果：" + num);
}
}
【面试题1】：如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？
- 相比run()，可以有返回值。
- 方法可以抛出异常。
- 支持泛型的返回值。
- 需要借助FutureTask类，比如获取返回结果。
Future接口
- 可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。
- FutrueTask是Futrue接口的唯一的实现类。
- FutureTask 同时实现了Runnable, Future接口。它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值。
使用线程池
提出背景
经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
实现思路
提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。
优点
- 提高响应速度（减少了创建新线程的时间）。
- 降低资源消耗（重复利用线程池中线程，不需要每次都创建）。
- 便于线程管理。
线程池相关的API
ExecutorService接口
真正的线程池接口。常见子类ThreadPoolExecutor。
【方法】：
- void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行
Runnable。 - Future submit(Callable task)：执行任务，有返回值，一般用来执行Callable。
- void shutdown() ：关闭连接池。
Executors类
工具类、线程池的工厂类，用于创建并返回不同类型的线程池。
- Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池。
- Executors.newFixedThreadPool(n)： 创建一个可重用固定线程数的线程池。
- Executors.newSingleThreadExecutor() ：创建一个只有一个线程的线程池。
- Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。
步骤
- 提供指定线程数量的线程池。
- 执行指定线程的操作。需要提供实现Runnable接口或者Callable接口实现类的对象。
- 关闭连接池。
【实例】：
class MyThread3 implements Runnable{
@Override
public void run() {
for(int i = 0;i < 100;i++){
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
public class ThreadPoolLen {
public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(10);
ThreadPoolExecutor threadPoolExecutor = (ThreadPoolExecutor) executorService;
threadPoolExecutor.setCorePoolSize(15);
executorService.execute(new MyThread3());
executorService.shutdown();
}
}
线程的调度
- 同优先级线程组成先进先出队列（先到先服务），使用时间片策略。
- 对高优先级，使用优先调度的抢占式策略。
线程的优先级
优先级等级
- MAX_PRIORITY ：10。
- MIN _PRIORITY ：1。
- NORM_PRIORITY ：5。
方法
- getPriority()：返回线程优先值。
- setPriority(int newPriority)：改变线程的优先级。
说明
- 线程创建时继承父线程的优先级。
- 低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用。
线程的分类
Java中的线程分为两类：一种是守护线程，一种是用户线程。
- 它们在几乎每个方面都是相同的，唯一的区别是判断JVM何时离开。
- 守护线程是用来服务用户线程的，通过在start()方法前调用thread.setDaemon(true)可以把一个用户线程变成一个守护线程。
- Java垃圾回收就是一个典型的守护线程。
- 若JVM中都是守护线程，当前JVM将退出。
线程的同步
问题提出
多线程出现了安全问题。
产生原因
当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错误。
解决办法
对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。
解决线程安全问题的方式有哪几种？
同步机制
同步代码块
synchronized (同步监视器){
//需要被同步的代码
}
说明：1.操作共享数据的代码，即为需要被同步的代码。
2.共享数据：多个线程共同操作的变量。
3.同步监视器：也称“锁”，任何一个类的对象，都可以充当锁。但是要保证多个线程共用同一把锁。
4.很多时候锁也指定为this或类名.class。
同步方法
synchronized 还可以放在方法声明中，表示整个方法为同步方法。
public synchronized void show (String name){
//需要被同步的代码
}
说明：1.同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
2.非静态的同步方法：同步监视器由this充当
静态的同步方法：同步监视器由当前类本身，也即类名.class充当。
Lock锁
- 通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
- java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
- ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。
class A{
private final ReentrantLock lock = new ReenTrantLock();
public void m(){
lock.lock();
try{
//保证线程安全的代码
}
finally{
lock.unlock();
}
}
}
说明：如果同步代码有异常，要将unlock()写入finally语句块中。
synchronized 和 Lock的异同？
相同点：二者都可以解决线程安全问题。
不同点：
- Lock是显式锁（手动开启和关闭锁），synchronized是隐式锁，出了作用域自动释放。
- Lock只有代码块锁，synchronized有代码块锁和方法锁。
- 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）。
释放锁的操作
- 当前线程的同步方法、同步代码块执行结束。
- 当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、该方法的继续执行。
- 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束。
- 当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。
不释放锁的操作
- 线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行。
- 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁（同步监视器）。
死锁问题
【产生原因】：不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。
【说明】：出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续。
【解决方法】：
- 专门的算法、原则。
- 尽量减少同步资源的定义。
- 尽量避免嵌套同步。
【实例】：
class A {
public synchronized void foo(B b) {
System.out.println("当前线程名: " + Thread.currentThread().getName()
+ " 进入了A实例的foo方法");
try {
Thread.sleep(200);
} catch (InterruptedException ex) {
ex.printStackTrace();
}
System.out.println("当前线程名: " + Thread.currentThread().getName()
+ " 企图调用B实例的last方法");
b.last();
}
public synchronized void last() {
System.out.println("进入了A类的last方法内部");
}
}
class B {
public synchronized void bar(A a) {
System.out.println("当前线程名: " + Thread.currentThread().getName()
+ " 进入了B实例的bar方法");
try {
Thread.sleep(200);
} catch (InterruptedException ex) {
ex.printStackTrace();
}
System.out.println("当前线程名: " + Thread.currentThread().getName()
+ " 企图调用A实例的last方法");
a.last();
}
public synchronized void last() {
System.out.println("进入了B类的last方法内部");
}
}
public class DeadLock implements Runnable {
A a = new A();
B b = new B();
public void init() {
Thread.currentThread().setName("主线程");
// 调用a对象的foo方法
a.foo(b);
System.out.println("进入了主线程之后");
}
public void run() {
Thread.currentThread().setName("副线程");
// 调用b对象的bar方法
b.bar(a);
System.out.println("进入了副线程之后");
}
public static void main(String[] args) {
DeadLock dl = new DeadLock();
new Thread(dl).start();
dl.init();
}
}
线程的通信
wait() 与 notify() 和 notifyAll()
- wait()：令当前线程挂起并放弃CPU、同步资源并等待，使别的线程可访问并修改共享资源，而当前线程排队等候其他线程调用notify()或notifyAll()方法唤醒，唤醒后等待重新获得对监视器的所有权后才能继续执行。
- notify()：唤醒正在排队等待同步资源的线程中优先级最高者结束等待。
- notifyAll()：唤醒正在排队等待资源的所有线程结束等待。
【说明】：
- 这三个方法只有在synchronized方法或synchronized代码块中才能使用，否则会报
java.lang.IllegalMonitorStateException异常。 - 因为这三个方法必须有锁对象调用，而任意对象都可以作为synchronized的同步锁，因此这三个方法只能在Object类中声明。
sleep() 和 wait()的异同？
相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。
不同点：
1. wait() 通常被用于线程间交互/通信，sleep()通常被用于暂停执行。
2. Thread类中声明sleep()，Object类中声明wait()。
3. sleep()可以在任何需要的场景下被调用，而wait()必须在同步代码块或同步方法中被调用。
4. sleep()没有释放锁，而 wait()释放了锁。
5. wait() 方法被调用后，线程不会自动苏醒，需要别的线程调用同一个对象上的notify()或者 notifyAll() 方法。sleep()方法执行完成后，线程会自动苏醒。或者可以使用 wait(long timeout) 超时后线程会自动苏醒。
【实例】：
class Communication implements Runnable {
int i = 1;
public void run() {
while (true) {
synchronized (this) {
notify();
if (i <= 100) {
System.out.println(Thread.currentThread().getName() +
":" + i++);
} else
break;
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
扫一扫
4万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
