Java并发-线程基础 学习

Java并发-线程基础

---

线程状态转换

新建(New)

创建后尚未启动

可运行(Runnable)

可能正在运行，也可能正在等待 CPU 时间片。
包含了操作系统线程状态中的 Running 和 Ready。

阻塞(Blocking)

等待获取一个排它锁，如果其线程释放了锁就会结束此状态。

无限期等待(Waiting)

等待其它线程显式地唤醒，否则不会被分配 CPU 时间片。

限期等待(Timed Waiting)

• 无需等待其它线程显式地唤醒，在一定时间之后会被系统自动唤醒。
• 调用 Thread.sleep() 方法使线程进入限期等待状态时，常常用“使一个线程睡眠”进行描述。
• 调用 Object.wait() 方法使线程进入限期等待或者无限期等待时，常常用“挂起一个线程”进行描述。
• 睡眠和挂起是用来描述行为，而阻塞和等待用来描述状态。
• 阻塞和等待的区别在于，阻塞是被动的，它是在等待获取一个排它锁。而等待是主动的，通过调用 Thread.sleep() 和 Object.wait() 等方法进入。

死亡(Terminated)

可以是线程结束任务之后自己结束，或者产生了异常而结束。

线程的使用方式

有三种使用线程的方式

• 实现 Runnable 接口；
• 实现 Callable 接口；
• 继承 Thread 类。

实现 Runnable 和 Callable 接口的类只能当做一个可以在线程中运行的任务，不是真正意义上的线程，因此最后还需要通过 Thread 来调用。可以说任务是通过线程驱动从而执行的。

实现 Runnable 接口

需要实现 run() 方法。

通过 Thread 调用 start() 方法来启动线程。

实现 Callable 接口

与 Runnable 相比，Callable 可以有返回值，返回值通过 FutureTask 进行封装。

继承 Thread 类

同样也是需要实现 run() 方法，因为 Thread 类也实现了 Runable 接口。
当调用 start() 方法启动一个线程时，虚拟机会将该线程放入就绪队列中等待被调度，当一个线程被调度时会执行该线程的 run() 方法。

实现接口 VS 继承 Thread

实现接口会更好一些，因为:

• Java 不支持多重继承，因此继承了 Thread 类就无法继承其它类，但是可以实现多个接口；
• 类可能只要求可执行就行，继承整个 Thread 类开销过大。

基础线程机制

Executor

Executor 管理多个异步任务的执行，而无需程序员显式地管理线程的生命周期。这里的异步是指多个任务的执行互不干扰，不需要进行同步操作。

主要有三种Executor

• CachedThreadPool: 一个任务创建一个线程；
• FixedThreadPool: 所有任务只能使用固定大小的线程；
• SingleThreadExecutor: 相当于大小为 1 的 FixedThreadPool。

代码:

public static void main(String[] args) {
    ExecutorService executorService = Executors.newCachedThreadPool();
    for (int i = 0; i < 5; i++) {
        // 代码量小的话可以直接匿名内部类 ()->{}
        executorService.execute(new MyRunnable());
    }
executorService.shutdown();
}

Daemon

emmmm…守护线程

public static void main(String[] args) {
    Thread thread = new Thread(new MyRunnable());
    thread.setDaemon(true);
}

sleep()

Thread.sleep(millisec) 方法会休眠当前正在执行的线程，millisec 单位为毫秒。

sleep() 可能会抛出 InterruptedException，因为异常不能跨线程传播回 main() 中，因此必须在本地进行处理。线程中抛出的其它异常也同样需要在本地进行处理。

public void run() {
    try {
        Thread.sleep(3000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

yield()

给其他线程个建议,自己线程重要部分已经运行完成

线程中断

一个线程执行完毕之后会自动结束，如果在运行过程中发生异常也会提前结束。

interruptedException

通过调用一个线程的 interrupt() 来中断该线程，如果该线程处于阻塞、限期等待或者无限期等待状态，那么就会抛出 InterruptedException，从而提前结束该线程。但是不能中断 I/O 阻塞和 synchronized 锁阻塞。

Executor的中断操作

匿名内部线程

executorService.shutdown();
executorService.shutdownNow();

线程互斥同步

Java 提供了两种锁机制来控制多个线程对共享资源的互斥访问，第一个是 JVM 实现的 synchronized，而另一个是 JDK 实现的 ReentrantLock。

synchronized

1.同步一个代码块

锁一个类的时候,多个线程运行同一个实例的时候才不会干扰

public void func() {
    synchronized (this) {
        // ...
    }
}

2.同步一个方法

public void func() {
    synchronized (SynchronizedExample.class) {
        // ...
    }
}

它和同步代码块一样，作用于同一个对象。

3.同步一个类

public void func() {
    synchronized (SynchronizedExample.class) {
        // ...
    }
}

锁一个类的时候,多个线程运行怎么运行都不会干扰
不同的对象全局互斥,this只同一个对象互斥

4.同步一个静态方法

public synchronized static void fun() {
    // ...
}

作用于整个类
不同的对象全局互斥,普通方法只同一个对象互斥

ReentrantLock

ReentrantLock 是 java.util.concurrent(J.U.C)包中的锁。

private Lock lock = new ReentrantLock();

public void func() {
    lock.lock();
    try {
        for (int i = 0; i < 10; i++) {
            System.out.print(i + " ");
        }
    } finally {
        lock.unlock(); // 确保释放锁，从而避免发生死锁。
    }
}

使用选择

除非需要使用 ReentrantLock 的高级功能，否则优先使用 synchronized。这是因为 synchronized 是 JVM 实现的一种锁机制，JVM 原生地支持它，而 ReentrantLock 不是所有的 JDK 版本都支持。并且使用 synchronized 不用担心没有释放锁而导致死锁问题，因为 JVM 会确保锁的释放。#

线程之间协作

当多个线程可以一起工作去解决某个问题时，如果某些部分必须在其它部分之前完成，那么就需要对线程进行协调。f

join()

在线程中调用另一个线程的 join() 方法，会将当前线程挂起，而不是忙等待，直到目标线程结束。

wait() notify() notifyAll()

• 调用 wait() 使得线程等待某个条件满足，线程在等待时会被挂起，当其他线程的运行使得这个条件满足时，其它线程会调用 notify() 或者 notifyAll() 来唤醒挂起的线程。
• 它们都属于 Object 的一部分，而不属于 Thread。只能用在同步方法或者同步控制块中使用，否则会在运行时抛出
• IllegalMonitorStateExeception。使用 wait() 挂起期间，线程会释放锁。这是因为，如果没有释放锁，那么其它线程就无法进入对象的同步方法或者同步控制块中，那么就无法执行 notify() 或者 notifyAll() 来唤醒挂起的线程，造成死锁。

wait()和sleep()的区别

• wait() 是 Object 的方法，而 sleep() 是 Thread 的静态方法；
• wait() 会释放锁，sleep() 不会。

await() signal() signalAll()

就是ReeentrantLock版wait()notify()notifyAll()

java.util.concurrent 类库中提供了 Condition 类来实现线程之间的协调，可以在 Condition 上调用 await() 方法使线程等待，其它线程调用 signal() 或 signalAll() 方法唤醒等待的线程。相比于 wait() 这种等待方式，await() 可以指定等待的条件，因此更加灵活。

使用 Lock 来获取一个 Condition 对象。

private Condition condition = lock.newCondition();
condition.signalAll();