深入浅出Java多线程

线程

线程的概念，百度是这样解释的：

线程（英语：thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。在Unix System V及SunOS中也被称为轻量进程（lightweight processes），但轻量进程更多指内核线程（kernel thread），而把用户线程（user thread）称为线程。

1.1 线程与进程的区别

进程：指在系统中正在运行的一个应用程序；程序一旦运行就是进程；进程——资源分配的最小单位。

线程：系统分配处理器时间资源的基本单元，或者说进程之内独立执行的一个单元执行流。线程——程序执行的最小单位。

也就是，进程可以包含多个线程，而线程是程序执行的最小单位。

1.2 线程的状态

1. NEW:线程刚创建
2. RUNNABLE: 在JVM中正在运行的线程，其中运行状态可以有运行中RUNNING和READY两种状态，由系统调度进行状态改变。
3. BLOCKED: 线程处于阻塞状态，等待监视锁，可以重新进行同步代码块中执行
4. WAITING : 等待状态
5. TIMED_WAITING: 调用sleep() join() wait()方法可能导致线程处于等待状态
6. TERMINATED: 线程执行完毕，已经退出

1.3 Notify 和 wait ：

1. Notify 和 wait 的作用
   首先看源码给出的解释，这里翻译了一下：

Notify

唤醒一个正在等待这个对象的线程监控。如果有任何线程正在等待这个对象，那么它们中的一个被选择被唤醒。选择是任意的，发生在执行的酌情权。一个线程等待一个对象通过调用一个{@code wait}方法进行监视。

notify()需要在同步方法或同步块中调用，即在调用前，线程也必须获得该对象的对象级别锁

wait

导致当前线程等待，直到另一个线程调用
{@link java.lang.Object#notify()}方法或
{@link java.lang.Object#notifyAll()}方法。
换句话说，这个方法的行为就像它简单一样
执行调用{@code wait(0)}。
当前线程必须拥有该对象的监视器。线程
释放此监视器的所有权，并等待另一个线程
通知等待该对象的监视器的线程唤醒
通过调用{@code notify}方法或
{@code notifyAll}方法。然后线程等待，直到它可以重新取得监视器的所有权，然后继续执行。

wait()的作用是使当前执行代码的线程进行等待，它是Object类的方法，该方法用来将当前线程置入预执行队列中，并且在wait所在的代码行处停止执行，直到接到通知或被中断为止。在调用wait方法之前，线程必须获得该对象的对象级别锁，即只能在同步方法或同步块中调用wait方法。

2. wait 和 sleep 的区别。
   它们最大本质的区别是:sleep()不释放同步锁,wait()释放同步锁.
   还有用法的上的不同是:sleep(milliseconds)可以用时间指定来使他自动醒过来,如果时间不到你只能调用interreput()来强行打断;wait()可以用notify()直接唤起.

wait和sleep的区别还有：

• 这两个方法来自不同的类分别是Thread和Object
• 最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。

。

1.4 Thread.sleep() 和Thread.yield()的异同

1. 相同 ： sleep()和yield()都会释放CPU。

2. 不同： sleep()使当前线程进入停滞状态，所以执行sleep()的线程在指定的时间内肯定不会执行；yield()只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。
   sleep()可使优先级低的线程得到执行的机会，当然也可以让同优先级和高优先级的线程有执行的机会；yield()只能使同优先级的线程有执行的机会。

1.5 补充：死锁的概念

死锁： 指两个或两个以上的进程（或线程）在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。

死锁产生的四个必要条件（缺一不可）：

1. 互斥条件：顾名思义，线程对资源的访问是排他性，当该线程释放资源后下一线程才可进行占用
2. 请求和保持：简单来说就是自己拿的不放手又等待新的资源到手。
   线程T1至少已经保持了一个资源R1占用,但又提出对另一个资源R2请求，而此时，资源R2被其他线程T2占用，于是该线程T1也必须等待，但又对自己保持的资源R1不释放。
3. 不可剥夺：在没有使用完资源时，其他线性不能进行剥夺
4. 循环等待：一直等待对方线程释放资源

我们可以根据死锁的四个必要条件破坏死锁的形成

1.6 补充：并发和并行的区别

并发：是指在某个时间段内，多任务交替的执行任务。当有多个线程在操作时，把CPU运行时间划分成若干个时间段,再将时间段分配给各个线程执行。 在一个时间段的线程代码运行时，其它线程处于挂起状。
并行：是指同一时刻同时处理多任务的能力。当有多个线程在操作时，cpu同时处理这些线程请求的能力。
区别就在于CPU是否能同时处理所有任务，并发不能，并行能

1.7 补充：线程安全三要素

原子性：Atomic包、CAS算法、synchronized、Lock

可见性：synchronized、volatile（不能保证原子性）

有序性：happens-before规则

1.8 补充：如何实现线程安全

• 互斥同步：synchronized、lock
• 非阻塞同步：CAS
• 无需同步的方案：如果一个方法本来就不涉及共享数据，那它自然就无需任何同步操作去保证正确性

1.9 补充：保证线程安全的机制：

1. synchronized关键字
2. lock
3. CAS、原子变量
4. ThreadLocl： 简单来说就是让每个线程，对同一个变量，都有自己的独有副本，每个线程实际访问的对象都是自己的，自然也就不存在线程安全问题了。
5. volatile
6. CopyOnWrite写时复制

1.10 谈谈对对多线程的理解

多线程开发中，最好每个线程是独立的，这样不用加锁，性能与代码安全性都好，比如起了5个线程处理List，可以实现用hash函数把list分成5份，每个线程启动的时候只处理自己对应的那一份就行。使用容器类，比如BlockQueue阻塞队列或者ConCurrentHashMap,利用生产消费者等设计模型，能够解决绝大多数并发问题。

线程内部的独立变量如果不与外部交互的话，可以使用ThreadLocal类（下方有介绍）。

多线程开发中应该优先使用高层API（比如信号量Semaphore，回环栅栏CyclicBarrier等，也需要对应的使用场景），
如果无法满足，使用java.util.concurrent.atomic（比如AtomicInteger原子操作类）和java.util.concurrent.locks包提供的中层API（一般都是用ReentrantLock的lock()，unlick()方法处理锁，用的主要也是中层API），
而synchronized和volatile，以及wait,notify和notifyAll等低层API 应该最后考虑。

1.11 run和Start方法的区别

1. run方法是Runnable接口中定义的，start方法是Thread类定义的。
   而Thread类又实现了Runnable接口
2. 通过start(）方法，直接调用run()方法可以达到多线程的目的
3. run()和start()的区别可以用一句话概括：单独调用run()方法，是同步执行；通过start()调用run()，是异步执行。
4. 总之，只有调用了start()方法，才会表现出多线程的特性，不同线程的run()方法里面的代码交替执行。如果只是调用run()方法，那么代码还是同步执行的，必须等待一个线程的run()方法里面的代码全部执行完毕之后，另外一个线程才可以执行其run()方法里面的代码。

多线程

随着CPU核心的增多以及互联网迅速发展，单线程的程序处理速度越来越跟不上发展速度和大数据量的增长速度，多线程应运而生，充分利用CPU资源的同时，极大提高了程序处理速度。

2 创建线程的方法

• 继承Thread类

public class ThreadCreateTest {
   
    public static void main(String[] args) {
   
        new MyThread().start();
    }
}

class MyThread extends Thread {
   
    @Override
    public void run() {
   
        System.out.println(Thread.currentThread().getName() + "\t" + Thread.currentThread().getId());
    }
}

• 实现Runable接口

public class RunableCreateTest {
   
    public static void main(String[] args) {
   
        MyRunnable runnable = new MyRunnable();
        new Thread(runnable).start();
    }
}

class MyRunnable implements Runnable {
   
    @Override
    public void run() {
   
        System.out.println(Thread.currentThread().getName() + "\t" + Thread.currentThread().getId());
    }
}

• 通过Callable和Future创建线程

public class CallableCreateTest {
   
    public static void main(String[] args) throws Exception {
   
    	 // 将Callable包装成FutureTask，FutureTask也是一种Runnable
        MyCallable callable = new MyCallable();
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        new Thread(futureTask).start();

        // get方法会阻塞调用的线程
        Integer sum = futureTask.get();
        System.out.println(Thread.currentThread().getName() + Thread.currentThread().getId() + "=" + sum);
    }
}


class MyCallable implements Callable<Integer> {
   

    @Override
    public Integer call() <