Java 线程

线程

1. 进程、线程和多线程

进程概念：

进程是指计算机中正在运行得程序的实例称为进程，一个程序就是一个完整的进程，进程需要使用计算机中 CPU 内存 硬盘 网络 GPU 能耗等资源，这些资源由操作系统分配，核心资源是 CPU 和 内存。

线程概念

线程时进程的组成部分，不同线程执行不同的任务，不同的功能模块，同时线程使用的资源是由进程管理，主要分配 CPU 和内存。
在进程中，线程和执行方式是抢占式执行，需要考虑当前线程是否持有 CPU 的执行权和等待权，同时关注线程的状态。

多线程

线程时一条执行路径，让 CPU 来执行代码，在开发 Java 应用程序的时候，使用多线程可以提高程序性能和效率，同时让程序变得更加流畅和易用。Java中的多线程编程是非常方便的，因为 Java 提供了丰富的库和 API，这些库和 API 可以方便地创建和管理线程。

当进程中所有线程执行完毕，线程关闭，当前进程也关闭，并释放资源。

2. 线程实现方式

在 Java 中有两种方式可以实现线程，一种是继承 Thread 类，另一种是实现 Runnable 接口。

2.1 继承 Thread 类

继承 Thread 类：在 Java 中我们可以继承 Thread 类来实现线程，这个类有一个 run() 方法需要进行重写，并在其中定义线程要执行的任务。然后我们可以创建一个 Thread 对象，并传入创建的类的实例，调用 Thread 对象的 start() 方法来启动线程。

class MyThread extends Thread {
    @Override
    public void run() {
        // 线程代码
    }
}
public static void main(String[] args) {
    // 实例化自定义继承 Thread 类子类对象
    MyThread thread = new MyThread();
    // 利用继承父类的 Thread 中的 start 方法启动线程
    thread.start();
}

2.2 实现 Runnable 接口

实现 Runnable 接口：Java 中可以通过实现 Runnable 接口来实现线程。我们需要实现 Runnable 接口中的 run() 方法，并将实现了 Runnable 接口的对象作为参数传给 Thread 类的构造函数，然后调用 Thread 的 start() 方法来启动线程。

class MyThread implements Runnable {
     @Override
    public void run() {
        // 线程代码
    }
}
public static void main(String[] args) {
    /*
    利用 Thread 类构造方法实例化目标进程对象，执行对应线程目标，将 Runnable 	 
    接口的实现类对象作为 Thread 构造方法参数
    */
    Thread thread = new Thread(new MyThread());
    
    thread.start();
}

2.3 案例代码

class MyThread1 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("继承 Thread 类");
        }
    }
}

class MyThread2 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("实现 Runnable 接口");
        }
    }
}
public class Demo1 {
    public static void main(String[] args) {
        MyThread1 thread1 = new MyThread1();
        Thread thread2 = new Thread(new MyThread2());

        thread1.start();
        thread2.start();
        for (int i = 0; i < 5; i++) {
            System.out.println("main方法内容");
        }
    }
}

3. 常用方法介绍

构造方法:
	Thread();
		过
	Thread(Runnable target);
		以 Runnable 接口实现类为当前线程的执行目标，new 关键字 + 构造方法实例化线程对象
	Thread(Runnable target, String threadName);
		以 Runnable 接口实现类为当前线程的执行目标，同时明确当前线程的名字，
		new 关键字 + 构造方法实例化线程对象

成员方法:
	String getName();
	void setName(String name);
		针对于线程名称的获取和设置
	
	int getPriority();
	void setPriority(int newPriority);
		针对于线程优先级的获取和设置
            优先级为 1 ~ 10，默认优先级为 5
            
void setDaemon(boolean flag);
	boolean isDaemon();
		设置和判断当前线程是否为守护线程
		flag 为 true 表示守护线程
	
静态成员方法：
	public static void sleep(int ms) throws InterruptedException;
		在哪一个线程代码中执行，哪一个线程代码进入【定时睡眠阻塞】状态
    public static Thread currentThread(); 
    	在哪一个线程代码中执行，获取当前线程代码对应的线程对象。           

4. 线程同步

在多线程程序中，如果多个线程同时访问同一个资源，就会出现资源竞争，为了解决多线程操作共享资源冲突问题，需要使用线程同步机制，通过线程同步操作，限制数据访问，保证线程之间的数据统一。

Java中提供了以下几种线程同步机制：

• synchronized关键字：用于控制对临界区的访问，保证同一时间只有一个线程可以访问临界区。
• wait()和notify()方法：用于实现线程的等待和通知机制。
• Lock接口：提供了更加灵活和强大的线程同步机制。

常用解决方案：

1. 同步代码块
2. 同步方法

4.1 同步代码块

4.1.1 同步代码块格式

synchronized (/* 锁对象 */) {
    // 限制同步的代码
}

4.1.2 Synchronized 同步代码块的要求

1. 同步限制的线程对象之间，使用的锁对象是同一个对象。
2. 同步代码块中的代码，尤其只允许一个线程对象进入执行
3. 线程对象进入同步代码块执行功能代码，会自动落锁，其他线程进入 LOOKED 锁阻塞状态，执行完毕，会自动开锁

4.1.3 同步代码块中锁对象选择

1. 必须保证唯一性
2. 通常一个类内会设置一个独立的变量作为锁对象使用
3. 包装类不得用于锁对象的使用

4.1.4 案例代码

public class MyThread implements Runnable {

    private final Object lock = new Object();
    
    @Override
    public void run() {
        sychronized (lock) {
            for (int i = 1; i <=5; i++){
                System.out.println(i);
            }
        }               
    }
}
public class Demo {
    public static void main(String[] args) {
      MyThread thread1 = new MyThread();
      MyThread thread2 = new MyThread();

      Thread t1 = new Thread(thread1);
      Thread t2 = new Thread(thread2);

      t1.start();
      t2.start();
    }
}

在这个案例中，我们创建了一个实现了 Runnable 接口的线程类 MyThread。 MyThread 类中有一个私有的 Object 对象 lock，用这个对象来控制线程同步。在 MyThread 类的 run() 方法中，使用 synchronized 关键字来进入同步代码块，进程上锁，直到线程执行完毕才会释放锁。

在 Demo 类中创建了两个线程并开始执行，由于 MyThread 类中的同步代码块使用了 lock 对象作为锁，因此两个线程不能同时执行这个代码块，将会实现交替执行，实现线程同步。

4.2 同步方法

同步方法：使用 synchronized 关键字修饰的方法、

限制对应的方法中有且只有一个线程可以进入方法中执行目标任务。

同步方法分为 非静态同步方法 和 静态同步方法

4.2.1非静态同步方法

非静态同步方法锁对象时候当前调用方法的锁对象 this

使用 synchronized 同步约束，同步范围如下：当前对象一旦执行 Synchronized同步方法，其他同步方法无法执行

4.2.2 静态同步方法

static 修饰的 synchronized 约束的同步方法，锁对象是当前类名.class。无论哪一个线程，哪一个对象来执行目标方法，都会被 类名.class 锁住，即不考虑代码范围，一旦静态成员 Synchronized 同步方法执行，其他静态同步方法无法执行。

public static synchronized void test() {
    for (int i = 0; i < 5; i++) {
        try {
            Thread.sleep(800);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("测试方法");
    }
}

5. 线程通信

5.1 线程状态

在Java中，线程有五种状态：

• 新建状态（New）：当线程对象被创建时，它处于新建状态，还没有开始执行
• 就绪状态（Runnable）：当线程调用 start() 方法后，线程进入就绪状态，等待 CPU 分配时间片并执行
• 运行状态（Running）：当线程获得 CPU 时间片并开始执行时，线程进入运行状态
• 阻塞状态（Blocked）：当线程因为某些原因无法继续执行时，线程进入阻塞状态，比如线程调用了 sleep() 方法、等待 IO操作。
• 终止状态（Terminated）：线程任务执行完毕，或者出现了异常，线程进入终止状态。

5.2 wait 和 notify 方法

wait 和 notify 是 Java 中的两个方法，用于线程间的通信。一般情况下，wait 和 notify 方法都是和 synchronized 关键字一起使用的，因为只有在 synchronized 块或方法中有对象监视器的概念。在调用 wait 和 notify 方法是，必须持有对象监视器锁，否则会抛出 IllegalMonitorStateException 异常。wait 和 notify 方法必须在同步代码块或同步方法中使用才能保证线程安全。

void wait();
	通过锁对象调用，当前线程进入无限等待状态，
	等待notify 和 notifyAll 方法，唤醒
	
void wait(long timeout);
	通过锁对象调用，当前线程进入计时等待状态，
	可以在休眠指定的时间之后自己醒来，
	或者被 notify 和 notifyAll 方法，唤醒

notify();
	通过锁对象调用，随机唤醒一个通过当前锁对象睡眠的线程对象。
    
notifyAll();
	通过锁对象调用，唤醒所有通过当前锁对象睡眠的线程对象。
        
wait notify notifyAll 方法都会打开锁对象，允许其他线程抢占执行