Java SE（十二）之多线程

概述

1.进程&线程

进程：是正在运行的程序
是系统进行资源分配和调用的独立单位，每一个进程都有它自己的内存空间和系统资源

线程：是进程中的单个顺序控制流，是一条执行路径

• 单线程:一个进程如果只有一条执行路径，则称为单线程程序
• 多线程:一个进程如果有多条执行路径，则称为多线程程序

2.并行&并发

并行：在同一时刻，有多个指令在多个CPU上同时执行
（一边吃面包一边写字）

并发：在同一时间间隔，有多个指令在单个CPU上交替执行。
（在8.00-8.30时间段内，先吃面包再写字）

线程创建方式

1.第一种：继承Thread类

步骤：
（1）定义一个子类（MyThread）继承线程类java.lang.Thread，重写run()方法

（2）创建这个类（MyThread）的对象

（3）调用线程对象的 start( ) 方法启动线程（启动后还是执行run方法的）

注意：
Q1：为什么要重写run()方法?
因为run()是用来封装被线程执行的代码

Q2：为什么不直接调用了run方法，而是调用start启动线程 ？
直接调用run方法会当成普通方法执行，此时相当于还是单线程执行。只有调用start方法才是启动一个新的线程执行。

e.g

 Thread t1 = new Thread()
        {
    
            @Override
            public void run()
            {
    
                for(int i=0;i<10;i++)
                   System.out.println("子线程输出："+i);
            }
        };
  t1.start()

如果是IDEA中会提醒可以用Lambda表达式（用上面的就可以了）

 Thread t1 = new Thread(() -> {
    
            for(int i=0;i<10;i++)
               System.out.println("子线程输出："+i);
        });
 t1.start();

不熟悉匿名内部类的可以看完整版

/**1、定义一个线程类继承Thread类 */
class MyThread extends Thread{
    
    /** 2、重写run方法，里面是定义线程以后要干啥 */
    @Override
    public void run() {
    
        for (int i = 0; i < 5; i++) {
    
            System.out.println("子线程执行输出：" + i);
        }
    }
    
public class ThreadDemo1 {
    
    public static void main(String[] args) {
    
        // 3、new一个新线程对象
        MyThread t = new MyThread();
        // 4、调用start方法启动线程（执行的还是run方法）
        t.start();

        for (int i = 0; i < 5; i++) {
    
            System.out.println("主线程执行输出：" + i);
        }
    }
}

2.第二种：实现Runnable接口

步骤：
（1）定义一个线程任务类MyRunnable类实现Runnable接口，重写run()方法

（2）创建MyRunnable任务对象

（3）创建Thread类的对象，把MyRunnable对象作为构造方法的参数（即把MyRunnable任务对象交给Thread处理）

（4）调用线程对象的start()方法启动线程

e.g.

Runnable runnable = new Runnable() {
    
   @Override
   public void run() {
    
         System.out.println("Hello");
     }
 };

// 或者直接lambda表达式
// new Thread(() -> System.out.println("实现runnable接口")).start();
 
Thread t = new Thread(runnable);
t.start();        

不熟悉匿名内部类的可以看完整版：

public class ThreadDemo2 {
    
/** 1、定义一个线程任务类 实现Runnable接口 */
  class MyRunnable  implements Runnable {
    
    /** 2、重写run方法，定义线程的执行任务的 */
    @Override
    public void run() {
    
        for (int i = 0; i < 10; i++) {
    
            System.out.println("子线程执行输出：" + i);
        }
 }
 
  public static void main(String[] args) {
    
        // 3、创建一个任务对象
        Runnable target = new MyRunnable();
        
        // 4、把任务对象交给Thread处理
        Thread t = new Thread(target);
        // Thread t = new Thread(target, "1号");
        
        // 5、启动线程
        t.start();

        for (int i = 0; i < 10; i++) {
    
            System.out.println("主线程执行输出：" + i);
        }
    }
}

3.Callable、FutureTask接口

jdk5新增的创建方式，相比于Runnable接口可以有返回值

基本步骤：

• 定义FutureTask类，并重写call方法
• 创建Thread类的对象，把FutureTask对象作为构造方法的参数
• 启动线程
• 再调用get方法，就可以获取线程结束之后的结果。

// 创建任务对象
FutureTask<Integer> task3 = new FutureTask<>(() -> {
    
 log.debug("hello");
 return 100;
});
// 参数1 是任务对象; 参数2 是线程名字，推荐
new Thread(task3, "t3").start();
// 主线程阻塞，同步等待 task 执行完毕的结果
Integer result = task3.get();
log.debug("结果是:{}", result);

4.线程创建的三种方式对比

相比直接继承Thread类，实现Runnable接口有如下好处：

• 避免Java单继承限制，但是通过实现Runnable接口，可以在同一个类中实现多个接口。这使得线程类能够继续扩展其他类的功能，而不仅限于Thread类。

• 提高代码的重用性：通过实现Runnable接口，线程类可以将线程的执行逻辑与线程的管理逻辑分离。

• 分离线程与任务：通过实现Runnable接口，线程类只负责线程的管理，而不关注具体的任务逻辑。

Thread常用方法

1.设置和获取线程名称

2.线程调度

3.线程控制

4.线程生命周期

线程的状态和转换方式

线程安全

1.线程安全问题出现的原因？

（1）存在多线程并发

（2）同时访问共享资源

（3）存在修改共享资源

2.解决方案——线程同步

加锁：把共享资源进行上锁，每次只能一个线程进入访问完毕以后解锁，然后其他线程才能进来。

加锁方式：

（1）同步代码块

（2）同步方法

生产者与消费者

1.背景

2.wait & notify

object类的方法