Java并发编程知识点

Java并发编程

---

Java并发编程包括以下内容：

• 线程状态
• 悲观锁和乐观锁
• 并发编程三要素
• 线程之间协作
• volatile关键字
• synchronized关键字
• CAS
• AQS
• Future
• 线程池

---

线程状态

线程状态有以下5类：

• 新建状态：新创建了一个线程对象
• 就绪状态：线程对象创建后，其他线程调用了该对象的start()方法，该状态的线程位于可执行线程池中，变得可执行，等待获取cpu的使用权
• 执行状态：就绪状态的线程获取了CPU，执行程序代码
• 堵塞状态;堵塞状态是线程由于某种原因放弃CPU使用权。临时停止执行。直到线程进行就绪状态，才有机会转到执行状态
• 死亡状态：线程运行完了或者因异常退出了run()方法，该线程结束生命周期
  

并发编程三大要素

• 原子性：
  原子，即一个不可再被分割的颗粒。在Java中原子性指的是一个或多个操作要么执行成功要么全部执行失败
• 有序性：
  程序执行的顺序按照代码的先后顺序执行
• 可见性 ：
  当多个线程访问同一个变量时，如果其中一个线程对其作了修改，其他线程会获取到最新的值

悲观锁和乐观锁

• 悲观锁：每次操作都会加锁，会造成线程阻塞。
• 乐观锁：每次操作不加锁而是假设没有冲突而去完成某项操作，如果因为冲突失败就重试，直到成功为止，不会造成线程阻塞。

线程之间协作

• wait()：wait()的作用是让当前线程进入等待状态，同时，wait()也会让当前线程释放它所持有的锁。“直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法”，当前线程被唤醒(进入“就绪状态”)

class ThreadA extends Thread{
    public ThreadA(String name) {
        super(name);
    }
    public void run() {
        synchronized (this) {
            try {
                Thread.sleep(1000); //  使当前线阻塞 1 s，确保主程序的 t1.wait(); 执行之后再执行 notify()
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+" call notify()");
            // 唤醒当前的wait线程
            this.notify();
        }
    }
}
public class WaitTest {
    public static void main(String[] args) {
        ThreadA t1 = new ThreadA("t1");
        synchronized(t1) {
            try {
                // 启动“线程t1”
                System.out.println(Thread.currentThread().getName()+" start t1");
                t1.start();
                // 主线程等待t1通过notify()唤醒。
                System.out.println(Thread.currentThread().getName()+" wait()");
                t1.wait();  //  不是使t1线程等待，而是当前执行wait的线程等待
                System.out.println(Thread.currentThread().getName()+" continue");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

运行结果：
main start t1
main wait()
t1 call notify()
main continue

• wait()一定要使用syncronized进行同步，否则会报“java.lang.IllegalMonitorStateException”异常。这是因为wait方法会释放对象锁，而此时因为没有用synchronized同步，就没有锁，就会报异常。

• 锁指的是synchronized修饰的方法、对象、代码块，如下实例中的value。 -

• 因为wait()释放了锁，故其他线程可以执行本来由synchronized修饰的内容。例如下面实例中的run()方法内打印value值（System.out.println(value);）。

• sleep():
  让当前线程暂停指定时间，只是让出CPU的使用权，并不释放锁

• yield( )方法：
  使当前线程从执行状态（运行状态）变为可执行态（就绪状态）。cpu会从众多的可执行态里选择，也就是说，当前也就是刚刚的那个线程还是有可能会被再次执行到的，并不是说一定会执行其他线程而该线程在下一次中不会执行到了。

---

Volatile关键字

---

volatile原理

java语言提供了一种稍弱的同步机制，即volatile变量，用来确保将变量的更新操作通知到其他线程。当把变量声明为volatile类型后，编译器与运行时都会注意到这个变量是共享的，因此不会将该变量上的操作与其他内存操作一起重排序。volatile变量不会被缓存在寄存器或者对其他处理器不可见的地方，因此在读取volatile类型的变量时总会返回最新写入的值。在访问volatile变量时不会执行加锁操作，因此也就不会使执行线程阻塞，因此volatile变量是一种比sychronized关键字更轻量级的同步机制。

synchronized

为什么要使用synchronized

在并发编程中存在线程安全问题，主要原因有：1.存在共享数据 2.多线程共同操作共享数据。关键字synchronized可以保证在同一时刻，只有一个线程可以执行某个方法或某个代码块，同时synchronized可以保证一个线程的变化可见（可见性），即可以代替volatile。

实现原理

synchronized可以保证方法或者代码块在运行时，同一时刻只有一个方法可以进入到临界区，同时它还可以保证共享变量的内存可见性

synchronized的三种应用方式

Java中每一个对象都可以作为锁，这是synchronized实现同步的基础：

1. 普通同步方法（实例方法），锁是当前实例对象 ，进入同步代码前要获得当前实例的锁
2. 静态同步方法，锁是当前类的class对象 ，进入同步代码前要获得当前类对象的锁
3. 同步方法块，锁是括号里面的对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。

synchronized的作用

Synchronized是Java中解决并发问题的一种最常用最简单的方法 ，他可以：

• 确保线程互斥的访问同步代码
• 保证共享变量的修改能够及时可见
• 有效解决重排序问题。

CAS

CAS操作的就是乐观锁，每次不加锁而是假设没有冲突而去完成某项操作，如果因为冲突失败就重试，直到成功为止。CAS是英文单词Compare And Swap的缩写，翻译过来就是比较并替换。CAS机制当中使用了3个基本操作数：内存地址V，旧的预期值A，要修改的新值B。更新一个变量的时候，只有当变量的预期值A和内存地址V当中的实际值相同时，才会将内存地址V对应的值修改为B。CAS是英文单词Compare And Swap的缩写，翻译过来就是比较并替换。CAS机制当中使用了3个基本操作数：内存地址V，旧的预期值A，要修改的新值B。更新一个变量的时候，只有当变量的预期值A和内存地址V当中的实际值相同时，才会将内存地址V对应的值修改为B。

AQS（抽象队列同步器）

AQS提供了一种实现阻塞锁和一系列依赖FIFO等待队列的同步器的框架
待更新