java并发编程的艺术学习笔记----第四章

前面的理论部分有点太枯燥的，直接从第四章来看吧。

 

1. 线程睡眠时间。

TimeUnit.Seconds.sleep(10)  //睡眠十秒

2. 线程放弃获取的时间片，重新与其他线程竞争时间片

Thread.yield()

3. volatilee

volatile实现原理是缓存锁。。能确保变量独一份。

4. 任意一个对象都拥有自己的监视器，当这个对象由同步块或者这个对象的同步方法调用时，这姓方法的线程必须先获取到该对象的监视器才能进入同步块或同步方法，否则线程被阻塞在同步块的入口处，进入 BLOCKED状态。

大前提：任意对象有自己的监视器

小前提：当这个对象由同步块或者这个对象的同步方法调用时，这姓方法的线程必须先获取到该对象的监视器才能进入同步块或同步方法，否则线程被阻塞在同步块的入口处，进入 BLOCKED状态。

结论：它主要确保多个线程在同一个时刻，只能有一个线程处于方法或者同步块中，它保证了线程对变量访问的可见性和排他性。

这里的监视器扮演者锁的角色

对象，同步队列，执行线程，监视器之间的关系

5. 

while (value != desire) {
Thread.sleep(1000);
}
doSomething();

 查看这段伪代码，用于当一个线程改变某个变量后另一个线程要做出处理。。。这段代码有两个问题：

1. 不及时，以1秒的频率监听，这样最长会有1秒的延时

2. 为了解决1中延时过长的问题，我们可以提高监听的频率，但是这样会造成cpu资源开销变大。

所以推出了java内置的   等待-通知机制。

下面的测试代码说明了上面的东西：

1. wait,notify ，之前都需要对对象进行加锁（也就是synchronized）；不然会报错 

 IllegalMonitorStateException - 如果当前线程不是此对象的监视器的所有者。

2. wait之后会释放锁，而notify只是将其他由于wait而进入等待队列的线程加入到同步队列，而不是直接可以运行了，所以notify是必要不充分条件。

3. 等待-通知机制依赖于同步机制，目的是确保等待线程从wait()方法返回时能够感知到通知线程对变量做出的修改。

import java.sql.Time;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.TimeUnit;

//测试wait, notify方法
public class solution2 {
    public static Object lock = new Object();
    public static boolean flag = true;

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new Wait(),"waitThread");
        thread.start();
        thread = new Thread(new notify(),"notifyThread");
        thread.start();
        TimeUnit.SECONDS.sleep(2);
    }

    static class Wait implements  Runnable{
        @Override
        public void run(){
            synchronized (lock){
                while (flag){
                    try {
                        System.out.println("wait1: "+ new SimpleDateFormat("HH:MM:ss").format(new Date()));
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("wait2: "+ new SimpleDateFormat("HH:MM:ss").format(new Date()));
                    try {
                        TimeUnit.SECONDS.sleep(2);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    static class notify implements Runnable{
        @Override
        public void run() {
            synchronized (lock){
                flag = false;
                lock.notify();
                System.out.println("notify"+ new SimpleDateFormat("HH:MM:ss").format(new Date()));
                try {
                    TimeUnit.SECONDS.sleep(5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

6. Thread.join()

在b线程的方法中调用a线程的join方法,意味着b线程需要等到a线程结束后才能继续运行。

7.ThreadLocal的使用 源码解析

8. 对于同步队列，加入同步队列时需要加锁，而退出同步队列不需要。

就像排队取票，退出队列的人时确定的，但是加入排队队列则需要先对队列进行加锁，不然a,b可能同时加锁到了tail，这样就很尴尬-----------------但是如果退出同步队列的时候想知道此时队列中有多少元素，还是要加锁。。

9. CAS （compareAndSet）是原子操作；