Java并发编程实战读书笔记-Chapter1

1.2线程的优势

获取当前机器逻辑处理器的个数

public class GetCoreNum {

    /**
     * 插槽：存放CPU芯片
     * 内核：CPU芯片上的处理器
     * 逻辑处理器：利用超线程技术，共享计算单元，将处理器衍生为两个逻辑的CPU
     */
    public static void main(String[] args) {
        System.out.println("逻辑处理器===》" + 
        Runtime.getRuntime().availableProcessors());
    }
}

1.2.1 发挥多处理器的能力

线程是基本的调度单位，多线程程序可以同时在多个处理器上执行。如果设计正确，多线程程序可以通过提高处理器利用率来提升系统吞吐率。
多个线程有助于在单处理器系统上获得更高的吞吐率。如果程序是单线程的，那么当程序在等待某个I/O操作完成时，处理器将处于空闲状态。
在多线程程序中，如果一个线程在等待I/O操作完成，另一个线程可以继续运行，使程序能够在I/O阻塞期间继续运行。（好比等待水烧开时看报纸，而不是等到水烧开之后再看报纸）

public class CpuAndThread {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            while (true) {
                System.out.println("t1阻塞等待输入：");
                final BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
                try {
                    final String str = reader.readLine();
                    System.out.println("==>" + str);
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        Thread t2 = new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("t2每两秒执行一次");

        });

        t1.start();
        t2.start();
    }
}

1.3线程带来的风险

1.3.1安全性问题

在没有充足通不的情况下，多个线程中的操作执行顺序是不额可以预测的。

@NotThreadSafe
public class UnsafeSequence {
    private int value;
    public int getNext() {
        return value++;
    }

    public static void main(String[] args) {
        final UnsafeSequence unsafeSequence = new UnsafeSequence();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() +
                        "==>" + unsafeSequence.getNext());
            }
        }).start();
        
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() +
                        "==>" + unsafeSequence.getNext());
            }
        }).start();
    }
}

上述代码在执行过程中，getNext有时会得到相同的值。value++实际上包含三个独立的操作，读取value，将value加1，将计算结果写入value。运行时可能将多个线程之间的操作交替执行，因此这两个线程可能同时执行读操作，从而使它们得到相同的值，并都将这个值加1。结果就是在不同线程的调用中返回了相同的数值。

通过将getNext修改为一个同步方法，可以修复UnsafeSequence中的错误。

public class UnsafeSequence {
    private int value;
    public synchronized int getNext() {
        return value++;
    }

多线程还会带来活跃性问题和性能问题。