重学java—线程基础

定义

线程：是操作系统进行调度的最小单位。
线程不占有内存空间，它包括在进程的内存空间中。在同一个进程内，多个线程共享进程的资源。一个进程至少有一个线程。

为什么需要多线程

并行：多个cpu实例或者多台机器同时执行一段处理逻辑，是真正的同时。
并发：通过cpu调度算法，让用户看上去同时执行，实际上从cpu操作层面不是真正的同时。

多线程其实是为了均衡 CPU 与 I/O 设备的速度差异；比如在访问网络接口时，将cpu让出，给别的线程使用；

众所周知，CPU、内存、I/O 设备的速度是有极大差异的，为了合理利用 CPU 的高性能，平衡这三者的速度差异，计算机体系结构、操作系统、编译程序都做出了贡献，
主要体现为: CPU 增加了缓存，以均衡与内存的速度差异；
操作系统增加了进程、线程，以分时复用 CPU，进而均衡 CPU 与 I/O 设备的速度差异；
编译程序优化指令执行次序，使得缓存能够得到更加合理地利用。

并发三要素

可见性：一个线程对共享变量的修改，另外一个线程能够立刻看到。
原子性：即一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。
有序性：即程序执行的顺序按照代码的先后顺序执行。

线程安全的方法

1.采取同步的方法，同步又可以分为互斥同步和非阻塞同步；也就是悲观锁和乐观锁
2.无同步方案
(一)栈封闭
多个线程访问同一个方法的局部变量时，不会出现线程安全问题，因为局部变量存储在虚拟机栈中，属于线程私有的
(二)线程本地存储(Thread Local Storage)
使用 java.lang.ThreadLocal 类来实现线程本地存储功能。把共享数据的可见范围限制在同一个线程之内，这样，无须同步也能保证线程之间不出现数据争用的问题。

线程状态

新建状态
创建后尚未启动。

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

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

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

限期等待状态
无需等待其它线程显式地唤醒，在一定时间之后会被系统自动唤醒。

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

线程使用方式

1.实现Runnable接口
2.实现Callable接口
3.继承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

守护线程是程序运行时在后台提供服务的线程，不属于程序中不可或缺的部分。
当所有非守护线程结束时，程序也就终止，同时会杀死所有守护线程。
main() 属于非守护线程。 使用 setDaemon() 方法将一个线程设置为守护线程。

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

线程互斥同步

JVM实现synchronized

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

对象锁，多线程执行同一个对象的方法时，进行互斥同步

public void func() {
    synchronized (SynchronizedExample.class) {
        // ...
    }
}
//类锁
等价于静态方法上加锁

JDK 实现的 ReentrantLock
ReentrantLock 是 java.util.concurrent(J.U.C)包中的锁，称其为可重入的互斥锁

public class LockExample {

    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(); // 确保释放锁，从而避免发生死锁。
        }
    }
}

线程之间协作

当多个线程可以一起工作去解决某个问题时，如果某些部分必须在其它部分之前完成，那么就需要对线程进行协调。
join()
在线程中调用另一个线程的 join() 方法，会将当前线程挂起，而不是忙等待，直到目标线程结束。

wait() notify() notifyAll()
调用 wait() 使得线程等待某个条件满足，线程在等待时会被挂起，当其他线程的运行使得这个条件满足时，其它线程会调用 notify() 或者 notifyAll() 来唤醒挂起的线程。

使用 wait() 挂起期间，线程会释放锁。这是因为，如果没有释放锁，那么其它线程就无法进入对象的同步方法或者同步控制块中，那么就无法执行 notify() 或者 notifyAll() 来唤醒挂起的线程，造成死锁。

wait() 和 sleep() 的区别

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

await() signal() signalAll()

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

public class AwaitSignalExample {
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    public void before() {
        lock.lock();
        try {
            System.out.println("before");
            condition.signalAll();
        } finally {
            lock.unlock();
        }
    }

    public void after() {
        lock.lock();
        try {
            condition.await();
            System.out.println("after");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

public static void main(String[] args) {
    ExecutorService executorService = Executors.newCachedThreadPool();
    AwaitSignalExample example = new AwaitSignalExample();
    executorService.execute(() -> example.after());
    executorService.execute(() -> example.before());
}
//输出before,after