《Java多线程编程核心技术》 笔记 未完待续

多线程

Thread类的核心方法

状态

• 启动
  start
• 暂停
  sleep(不释放锁 ;可能就睡过去了)\join\suspend-resume(过时-独占、不同步)
• 停止
  正常退出(执行完orReturn)\抛异常退出\interrupt(不是说中止就中止的)\yield自动放弃\stop(过时-不同步)
• 优先级
  可继承\规则性、随机性

守护线程

daemon，比如GC线程
keep with the last one, die with the last one

对象及变量的并发访问

多个线程对同一个对象中的实例变量进行并发访问时产生的数据不一致的问题，称为”非线程安全问题”。

synchronized 同步方法

1. 对象锁，不是一段代码或方法当做锁，对于共享资源的读写访问才需要同步化
2. 可重入，获得锁后未释放，再次获得锁；反之，则会造成死锁
3. 出现异常，自动释放锁

synchronized 同步块

1. 同步方法的弊端，当A线程调用同步方法执行一个耗时任务时，B线程必须一致等待
2. synchronized(this)
   2.1 当一个线程访问object的一个synchronized(this)同步代码块时，其他synchronized(this)块将被阻塞，即说明synchronized使用的”对象监视器”是一个。
   2.2 对象锁
3. 对象监视器非this对象，实现非this对象之间的异步调用
   3.1 当多个线程同时执行synchronized(x){}呈现同步效果
   3.2 当其他线程执行x对象中synchronized同步方法呈现同步效果
   3.3 当其他线程执行x对象方法里面synchronized(this)代码块也呈现同步效果，普通方法则呈现异步调用

死锁 deadlock

不同线程都在等待不可能被释放的锁

1. JDK内置工具使用
   
   • jps
   • jstack -l pid

volatile 关键字

使变量在多个线程中可见-强制从公共堆栈中取得变量的值，而不是从线程私有的数据栈中取值，避免两者不一致导致的异步死循环问题。

vs synchronized
1. volatile 修饰变量，访问不阻塞，不支持原子性
2. synchronize 修饰方法和代码块，阻塞，支持原子性和可见性（在私有内存和公共内存间做同步），多个线程访问资源的同步性；

总结

“外练互斥，内修可见”

线程间通信

• 使用wait()/notify()进行线程间通信
• 生产者/消费者模式实现
• join方法
• ThreadLocal类的使用

等待/通知机制

必须在synchronized同步的Object临界区内，
A-wait，释放被同步对象的锁，”与执行队列”
B-notify，唤醒一个调用了的wait操作处于阻塞状态的线程，使其进入就绪状态，但是要执行完B-notify后所有代码
C-notifyAll，唤醒所有

生产者/消费者模式

1. 一生产者一消费者

   • 操作值
   • 操作栈

2. 多生产者、消费者

   • 假死
     所有线程进入waiting状态，原因可能是唤醒同类，解决方法：notifyAll

通过管道进行线程间通信

Lock的使用

使用ReentrantLock & ReentrantReadWriteLock

synchronized进阶

• lock-unlock
• await-signal\signalAll
• 支持嗅探锁定 - isLocked/isHeldByCurrentThread
• 多路分支通知 - condition <-> Thread

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class MyService {

    public ReentrantLock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    private Condition newCondition = lock.newCondition();

    // 读写锁，读锁共享，写锁排他
    public ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    // 交替输出控制变量
    private boolean hasValue = false;

    /**
     * [基本测试]
     */
    public void test1() {
        lock.lock();
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + "---" + (i + 1));
        }
        lock.unlock();
    }

    /**
     * [await]
     */
    public void await() {
        try {
            lock.lock();
            System.out.println("await 时间为:" + System.currentTimeMillis());
            condition.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    /**
     * [signal]
     */
    public void signal() {
        lock.lock();
        System.out.println("signal 时间为:" + System.currentTimeMillis());
        condition.signal();
        lock.unlock();
    }

    /**
     * [输出★]
     */
    public void blackStar() {
        try {
            lock.lock();
            while (hasValue == true) {
                System.out.println("blackStar await");
                condition.await();
            }
            System.out.println("★");
            hasValue = true; // await backStar
            condition.signal();// notify whiteStar
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    /**
     * [输出☆]
     */
    public void whiteStar() {
        try {
            lock.lock();
            while (hasValue == false) {
                System.out.println("whiteStar await");
                condition.await();
            }
            System.out.println("☆");
            hasValue = false;// await whiteStar
            condition.signal();// notify whiteStar
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    /**
     * [lock调用次数]
     */
    public void testGetHoldCount1() {
        lock.lock();
        System.out.println("getHoldCount=" + lock.getHoldCount());
        testGetHoldCount2();
        lock.unlock();
    }

    /**
     * [lock调用次数]
     */
    private void testGetHoldCount2() {
        lock.lock();
        System.out.println("getHoldCount=" + lock.getHoldCount());
        lock.unlock();
    }

    /**
     * [返回等待获取此锁定的线程个数]
     */
    public void testInitQueueLength() {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "进入方法");
            Thread.sleep(Integer.MAX_VALUE);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        lock.unlock();
    }

    /**
     * [返回等待同一个Condition线程个数]
     */
    public void testGetWaitQueueLength() {
        lock.lock();
        try {
            newCondition.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        lock.unlock();
    }

    public void notifyNewCondition() {
        lock.lock();
        System.out.println("有" + lock.getWaitQueueLength(newCondition) + "在等待newCondition");
        newCondition.signalAll();
        condition.signalAll();
        lock.unlock();
    }

    /**
     * 读锁共享,读读异步,非互斥; 其他:读写,写读,写写互斥
     */
    public void read() {
        readWriteLock.readLock().lock();
        System.out.println(Thread.currentThread().getName() + "获得读锁,时间是:" + System.currentTimeMillis());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            readWriteLock.readLock().unlock();
        }
    }

    public void write() {
        readWriteLock.writeLock().lock();
        System.out.println(Thread.currentThread().getName() + "获得写锁,时间是:" + System.currentTimeMillis());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            readWriteLock.writeLock().unlock();
        }
    }

---

java.util.concurrent

locks

automic

Executor

container

ConcurrentHashMap

LinkedBlockingQueue