Java线程基础知识点整理

我正在参加「掘金·启航计划」

进程和线程的区别

进程是资源分配的最小单位，线程是cpu调度的最小单位。
进程可以看做独立应用，而线程不能。一个程序会产生一个进程，而一个进程包含一个或多个线程。
进程间是相互隔离的，线程可以共享进程内的资源

对象的共享

同步代码块及同步方法可以确保以原子形式执行操作，关键字synchronized不仅可以实现原子性、确定临界区；同时还可以保证内存可见性。

线程安全性

一个对象是否是线程安全的，取决于这个对象是否会被多个线程访问。并发编程中，线程安全问题归根结底其实就是 原子性、可见性、一致性、有序性问题。

原子性

一个操作或多个操作要么全部执行完成且执行过程不被中断，要么就不执行。

可见性

可见性指的是当多个线程存在时，某个线程对主内存的写入操作，其他线程都是立即可见的。

为什么要保证可见性呢？如：非volatile类型的64位数值变量(double、long)在进行读操作或写操作时会分解为两个32位的操作。如果多线程去读写该类型变量，可能会读取到某个值的高32位和另一个值的低32位。

有序性

程序执行的顺序按照代码的先后顺序执行。对于单线程，在执行代码时jvm会进行指令重排序，目的是为了提高效率。指令重排可以对输入代码进行优化，它不保证程序中各个语句的执行先后顺序同代码中的顺序一致，但是它会保证保存最终执行结果和代码顺序执行的结果是一致的。

加锁机制

多个线程访问同一个可变状态变量时，需要使用合适的同步，否则程序可能会出现错误。如果不想出现错误，可以通过下面的方式解决：

不在线程之间共享该状态变量
将状态变量修改为不可变的变量，即通过final修饰
多线程访问该变量时使用同步

原子性：原子操作指的是，对于访问同一个状态的所有操作都是一个以原子方式执行的操作。 竞态条件：当某个计算的正确性取决于多个线程的交替执行次序时，就会发生竞态条件。

Java提供了一种内置的锁机制来支持原子性，以关键字synchronized来实现，内置锁可以作用在对象上或者方法上，称为对象锁；另外内置锁也可以直接作用在static静态的方法上，称为类锁。

volatile

相对于synchronized，volatile是一种稍弱的同步机制，volatile可以确保将变量的更新操作通知到其他线程，从而可以保证可见性。同时volatile还可以防止指令重排。

加锁机制与volatile的异同：

加锁机制既可以保证可见性又可以保证原子性，volatile只能保证可见性不能保证原子性。

Thread中start()和run()方法的区别

Runnable接口：
public interface Runnable {
    public abstract void run();
}

Thread类实现了Runnable接口：
public class Thread implements Runnable {

  @Override
  public void run() {}

}

调用start()方法会新起一个线程并启动新线程;如果直接执行run()，那么并没有新起线程，而是Thread被当成了一个普通类并运行了其中的run()方法

Thread的状态

Thread.State类：

public static enum State {
    NEW,
    RUNNABLE,
    BLOCKED,
    WAITING,
    TIMED_WAITING,
    TERMINATED;

    private State() {
    }
}

NEW 创建后尚未启动(还未调用start)的线程的状态
RUNNABLE 正在执行的线程(Running)或者正在等待cpu分配时间片的状态(Ready)
BLOCKED 等待获取排它锁（互斥锁）

WAITING 无限期等待，此状态下的Thread不会被分配时间片，需要显式被唤醒。下列方法都会导致Thread处于Waiting状态：

1、Object.wait()：如果一个线程中调用了object.wait()，那么这个线程就会处于waiting状态直到另一个线程调用了object.notify或者object.notifyAll才解除
2、线程A中调用线程B的join()那么线程A的状态从Runnable状态变成了Waiting状态，直到线程B执行完，线程A才会继续执行。
3、LockSupport.park()方法

TIMED_WAITING 和Waiting状态是类似，但是是限期等待，即在一定时间后由系统自动唤醒。下列方法都会让Thread重新唤醒

1、Thread.sleep(long TimeOut)
2、Object.wait(long TimeOut),当TimeOut时间过后，当前Thread会重新获取cpu时间片并变成运行状态
3、Thread.join(long TimeOut)
4、LockSupport.parkNanos()
5、LockSupport.parkUntil()

TERMINATED 已终止线程的状态，线程已经结束执行。

Thread的几种状态之间的关系

Thread.State.png

sleep()和wait()的区别

两个方法来自不同的类：sleep()来自Thread，wait()来自Object。
sleep()没有释放锁，会继续持有锁；wait()释放了锁，其他线程可以抢占该锁。
wait()、notify()和notifyAll()只能在Synchronized关键字作用域内使用；而sleep()可以在任何地方使用（使用范围）
sleep()必须捕获异常，而wait()、notify()和notifyAll()不需要捕获异常
sleep()是Thread类的静态方法。sleep()的作用是让线程休眠指定的时间，在时间到达时恢复，也就是说sleep()将在设置的Time到达后恢复线程执行；wait()是Object的方法，也就是说可以对任意一个对象调用wait方法，调用wait()将会将调用者的线程挂起，直到其他线程调用同一个对象的notify()方法才会重新激活调用者。

notify()和notifyAll()的区别

先介绍两个概念，锁(monitor)池和等待池，wait、notify、notifyAll都是Object中的方法。

锁池: 假设线程A已经拥有了某个对象(注意:不是类)的锁，而其它的线程想要调用这个对象的某个synchronized方法(或者synchronized块)，由于这些线程在进入对象的synchronized方法之前必须先获得该对象的锁的拥有权，但是该对象的锁目前正被线程A拥有，所以这些线程就进入了该对象的锁池中。
等待池: 假设一个线程A调用了某个对象的wait()方法，线程A就会释放该对象的锁(因为wait()方法必须出现在synchronized中，这样自然在执行wait()方法之前线程A就已经拥有了该对象的锁)，同时线程A就进入到了该对象的等待池中。如果另外的一个线程调用了相同对象的notifyAll()方法，那么处于该对象的等待池中的线程就会全部进入该对象的锁池中，准备争夺锁的拥有权。如果另外的一个线程调用了相同对象的notify()方法，那么仅仅有一个处于该对象的等待池中的线程(随机)会进入该对象的锁池.

notify、notifyAll的区别：更详细，请移步：https://blog.csdn.net/u014561933/article/details/58639411

yield()

yield()是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。
yield()从未导致线程转到等待/睡眠/阻塞状态。在大多数情况下，yield()将导致线程从运行状态转到可运行状态，但有可能没有效果。

join()

阻塞当前线程，等待子线程执行完毕之后继续执行当前线程。

interrupt()

线程一旦开始执行，就不能强制停止，否则会产生致命的问题，如：持有的锁不能被释放。所以Thread.stop()等方法已经被废弃了。那么如果优雅的让线程结束呢？那就是给正在执行的线程一个中断信号, 让它自己决定该怎么办。中断一个线程只是为了引起该线程的注意，被中断线程可以决定如何应对中断。

thread.interrupt()：对于非阻塞中的线程, 只是改变了中断状态, 即thread.isInterrupted()将返回true; 对于可取消的阻塞状态中的线程, 如：Thread.sleep()、Object.wait()、Thread.join(), 这个线程收到中断信号后，会抛出InterruptedException, 同时会把中断状态置回为true。
Thread.interrupted()：当调用interrupt()后，Thread.interrupted()返回true，并且会对中断状态进行复位(此时isInterrupted()将返回false)。

使用示例：

public void run(){    
        try{    
             ....    
             while(!Thread.currentThread().isInterrupted()){    
                    // do more work;    
             }    
        }catch(InterruptedException e){    
                    // thread was interrupted during sleep or wait    
        }    
        finally{    
                   // cleanup, if required    
        }    
}

Thread.currentThread().interrupt();//中断信号