java并发编程之美-阅读记录1

为什么要将栈和程序计数器设置为线程私有的呢？
    前边说线程是cpu执行的基本单位，而cpu一般是使用时间片轮转方式轮询占用的，所以当当前线程cpu时间片使用完毕后，要让出cpu，等待下一次轮到自己的时候在调用。
那问题就来了，线程是如何知道之前执行到哪了？
    程序计数器就是为了记录之前让出cpu时执行到的地址，等下次再次执行时就可以从程序计数器中获取之前执行到的位置，继续向下执行。（程序计数器是不会记录native方法执行的地址的，它只记录java代码执行的地址），而栈则是存储现场的局部变量，一遍之后再次使用

package com.nxz.blog.otherTest;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class TestThread {

    static class MyThread1 extends Thread {
        @Override
        public void run() {
            System.out.println("extend-Thread："+this.getName());
        }
    }

    static class MyThread2 implements Runnable {

        @Override
        public void run() {
            System.out.println("implements-Runnable:"+Thread.currentThread());
        }
    }

    static class MyThread3 implements Callable<String> {

        @Override
        public String call() throws Exception {

            System.out.println("implements-Callable:"+Thread.currentThread());
            return "Callable接口";
        }
    }


    public static void main(String[] args) {
        MyThread1 t1 = new MyThread1();
        t1.start();

        Thread t2 = new Thread(new MyThread2());
        t2.start();

        FutureTask<String> futureTask = new FutureTask<>(new MyThread3());
        new Thread(futureTask).start();
        try {
            // 阻塞，等待执行完毕，并返回结果
            String res = futureTask.get();
            System.out.println(res);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        System.out.println("main-Thread");
    }
}

extend-Thread:Thread-0
implements-Runnable:Thread[Thread-1,5,main]
implements-Callable:Thread[Thread-2,5,main]
Callable接口
main-Thread

    public final void wait(long timeout, int nanos) throws InterruptedException {
        if (timeout < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }
        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
                                "nanosecond timeout value out of range");
        }
        if (nanos > 0) {
            timeout++;
        }
        wait(timeout);
    }

    static Queue queue;

    static class ProductThread extends Thread {
        @Override
        public void run() {
            synchronized (queue) {
                if (queue.size() == 1) {// 假设队列最多存一个对象
                    try {
                        queue.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                queue.add(new Object());
                queue.notifyAll();
            }
        }
    }

    static class ConsumerThread extends Thread {
        @Override
        public void run() {

            synchronized (queue) {
                if (queue.isEmpty()) {
                    try {
                        queue.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                queue.poll();
                queue.notifyAll();
            }
        }
    }

package com.nxz.blog.otherTest;

public class TestThread002 {

    static class MyThread extends Thread{
        @Override
        public void run() {
            System.out.println("myThread");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        MyThread t1 = new MyThread();
        t1.setName("myThread");
        t1.start();

        // 如果注释掉 下边代码的话，main方法的输出应该会是  先main-thread 然后再试mythread，
        // 放开的话 main主线程就会等待t1线程执行完毕后，在向下运行
        t1.join();

        System.out.println("main-thread");
    }
}

    public void set(T value) {
        Thread t = Thread.currentThread();
　　　　　// 当调用ThreadLocal的set方法时，其实是获取的是当前线程Thread中的ThreadLocalMap变量，如果变量为null，则新建一个ThreadLocalMap，如果变量存在，则之间将当前线程和value存入定制的map中（ThreadLocalMap）
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

　　// 从源码getMap中可以看出，其实获取的是当前线程中的threadLocals变量
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

    void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

    public T get() {
　　　　　// ThreadLocal的get方法，同样是获取的是当前线程Thread中的threadLocals变量（也就是ThreadLocalMap类型的数据）
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }