java并发-- 线程状态、优先级、同步以及锁

1 线程状态

线程的状态，参考Thread的内部枚举类型State是如何定义的：

core java.png

线程状态

1.1 New

被new出来的Thread对象，还没有开始运行时处于New状态。

1.2 Runnable

调用线程的start()方法之后的状态。可能正在运行，也可能没有。现代桌面操作系统都使用抢占式策略分配时间片，也就是优先级高的线程可以直接打断正在运行的优先级低的线程，抢占时间片。

1.3 blocked或者waiting

此时线程不运行任何代码，消耗很少的资源。

• Blocked
  当一个线程试图获取一个另一线程已经持有的 内部对象锁（intrinsic object lock），而不是concurrent library中的锁，就会处于Blocked的状态。即试图进入synchronized代码块失败时。

• Waiting
  当一个线程等待另一线程通知调度器某个条件时。例如：Object.wait()、Thread.join()以及等待concurrent library中的Lock或者Condition。（实践中与blocked的区别不是很明显）

• time-waiting
  通过调用带有时间参数的方法使得线程进入waiting状态。直到时间耗尽或者受到合适的消息通知时才会改变该状态。包括Thread.sleep、Object.wait、Thread.join、 Lock.tryLock、 Condition.await(都需要带上时间参数)。

当一个线程被激活（等待时间耗尽或者获取到锁），调度器会检查它的优先级是否高于当前运行线程的优先级，如果是的话，则抢占当前线程，选择一个新的线程运行。

1.4 Terminated

两个原因导致线程Terminated：

• run方法正常退出导致线程正常结束
• run方法出现未捕获异常

2 线程优先级

java每一个线程都优先级，优先级默认与创建该线程的线程优先级一致，默认为5。android官方文档推荐，每个线程都需要手动去设置优先级，这样有利于线程调度。

3 线程同步

3.1 为什么需要线程同步？

多个线程对同一共享数据进行读写，由于线程执行顺序的不同，有可能产生错误的结果。这种情况称之为“竞态条件”。
最常见的竞态条件就是“先检查后执行”操作(例如懒汉式单例模式)以及“读取--修改--写入”（例如a++）操作，即通过一个可能失效的观察结果来决定下一步的动作。在读取后，写入前， 中间任意时刻该变量都可能被其它线程修改。
基于以上竞态条件，需要对线程进行同步。即有多个线程对共享数据进行读写时，一个特定时刻只能有一个线程去操作该共享数据，别的线程只能等其操作完成之后再去操作。

3.2 如何进行线程同步

要做到一个特定时刻只能有一个线程去操作共享数据，很容易想到对共享数据进行加锁。java里面的加锁，是对持有该共享数据的对象进行加锁。每一个java对象，在内存中的布局分为3块区域：对象头、实例数据和对齐填充。在HotSpot虚拟机的实现中，对象头包含对象运行时的数据以及类型指针（标记该对象是哪个类的实例）。而运行时数据就包括hashcode、GC分代年龄、锁状态标记等信息。
java api有为我们提供了锁，可以直接拿来用，例如使用ReentrantLock保护代码块的基本结构为：

        ReentrantLock mLock = new ReentrantLock();
        mLock.lock();
        try {
            //critical section临界区
        }
        finally {
            mLock.unlock();
        }

在进入了临界区之前加锁，操作完成后释放锁。
这个结构可以确保任何时刻只有一个线程可以进入临界区。一旦有一个线程锁住了该对象，则其他线程再调用lock方法时，会被阻塞，直到该锁被释放。

释放锁的操作必须放在finally语句块中，要不然一定临界区代码抛异常，则该锁永远不会被释放，其他线程会永远阻塞。

注意，锁是可以重入的。即同一线程可以重复持有已经持有的锁。锁保持一个持有计数来跟踪对lock方法的嵌套调用。线程每一个调用lock之后，都要使用unlock来释放锁。基于以上机制，可以再同步方法中，调用另一个使用相同锁的方法。

3.3 条件对象

当线程获取锁之后进入临界区，发现条件不合适继续往下执行（显然条件判断应该处于临界区内，要不然又会产生竞态条件），需要有一个机制让其进入等待状态并释放锁，等条件适合其执行之后，再将其唤醒。显然，该线程进入等待状态时需要释放锁，这样其它线程才能进入临界区，改变条件。
举个栗子，银行转账时，需要转账金额不大于余额才能转账。

    Condition mCondition = mLock.newCondition();
    public void transform(int from,int to,int amount) throws InterruptedException{
        mLock.lock();
        try {
            while(amount>account[from]){
                //wait
                mCondition.await();
            }
            //转账
            ...
            mCondition.signalAll();
        }finally {
            mLock.unlock();
        }
    }

这里需要使用while循环，每次唤醒并分配到cpu时间片时，都需要检查条件是否满足。
另外，signalAll()只是解除该条件下等待线程的阻塞状态，以便当前线程退出之后，这些线程有资格被线程调度器执行。

注意：1 每一个锁可以有多个条件对象，用来细粒度的控制线程

3.4 synchronized关键字

前面介绍了Lock和Condition对象，理解自己加锁的方式之后，我们再来看java虚拟机自动给我们加锁的方式：synchronized。使用synchronized关键字，系统将自动加锁。每一个对象都有一个内部锁（Intrinsic Lock）。如果一个方法使用synchronized来申明，则系统自动使用该对象的内部锁。如果是static方法则使用该类的Class对象的内部锁。

示例.png

注意：内部对象锁只有一个相关条件。wait 方法添加一个线程到等待集中， notifyAll、notify方法解除等待线程的阻塞状态。

3.5 Lock和synchronized的对比

3.5.1 性能

java6使用了逐步升级的方式来管理内置锁，性能大大提高，两者性能差不多。

3.5.2 功能

synchronized为系统自动加锁和释放锁，使用更加简洁。
Lock则更加灵活。
synchronized有以下局限：

• 1 不能中断一个正在试图获取锁的线程。
• 2 不能为获取锁操作设定超时时间
  在开始请求锁之后，这个操作无法取消。
• 3 每个锁只有单一的条件，可能是不够的。
• 4 非公平锁
• 5 只能对代码块加锁
  即释放锁的操作与获取锁的操作处于同一个代码块。

Lock/Condition 结构提供的独有特性：

• 1 可以尝试获取锁，即轮询锁，并为获取锁操作设定超时时间
  可以根据尝试获取锁的结果进行下一步操作。

 ReentrantLock mLock = new ReentrantLock();
    public void testTryLock(){
        boolean locked = false;
//            locked = mLock.tryLock();
            locked = mLock.tryLock(5, TimeUnit.SECONDS);
        try {
            if(locked){

            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            if(locked){
                mLock.unlock();
            }
        }
    }

在共享通信线路上发一条消息，如果不能在指定时间内完成，代码就会失败。

    public boolean trySendOnSharedLine(String message,long timeout,TimeUnit unit) throws InterruptedException {
        if(!mLock.tryLock(timeout, unit)){
            return false;
        }
        try{
            return sendOnShareLine(message);
        }finally {
            mLock.unlock();
        }

• 2 可以中断试图获取锁的线程，即对interrupt进行响应

   ReentrantLock mLock = new ReentrantLock();
    public void testTryLock() {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    mLock.lockInterruptibly();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    mLock.unlock();
                }
            }
        });
//可以被打断        
        thread.interrupt();
    }

• 3 可以多条件控制
• 4 可以对非块结构进行加锁，例如散列容器的分段锁。
• 5 可以构造为公平锁。
  公平锁即安排等待锁的顺序获取锁，相对来说性能差一些，只有在确定需要这个功能时才初始化为公平锁。

结论：只有在需要使用Lock、 Condition的特有功能时，才使用Lock。

image.png

https://ysysdzz.gitbooks.io/theartofjavaconcurrencyprogramming/content/ch2/2.2.2%20%E9%94%81%E7%9A%84%E5%8D%87%E7%BA%A7%E4%B8%8E%E5%AF%B9%E6%AF%94.html