并发编程的艺术读书笔记

最新推荐文章于 2021-04-06 17:27:49 发布

梦想远航

最新推荐文章于 2021-04-06 17:27:49 发布

阅读量253

点赞数

分类专栏：并发编程

本文链接：https://blog.csdn.net/qq_31617121/article/details/88044873

版权

并发编程专栏收录该内容

11 篇文章 0 订阅

订阅专栏

第一章并发编程的挑战

1. 单核CPU分配运行时间给各个线程，实现多线程执行代码。

举例：看英文书时某个单词不会，先记住看到书的页数和行数，然后去查单词，查完回到看书状态，相当于上下文切换。

2. 多线程并不一定比串行执行代码快

举例：循环累加的代码，count=10000时，并发比串行执行慢，因为上下文切换有额外开销

public class ConcurrencyTest {
    private static final long count = 10000l;

    public static void main(String[] args) throws InterruptedException {
        concurrency();
        serial();
    }

    private static void concurrency() throws InterruptedException {
        long start = System.currentTimeMillis();
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                int a = 0;
                for (long i = 0; i < count; i++) {
                    a += 5;
                }
                System.out.println(a);
            }
        });
        thread.start();
        int b = 0;
        for (long i = 0; i < count; i++) {
            b--;
        }
        thread.join();
        long time = System.currentTimeMillis() - start;
        System.out.println("concurrency :" + time + "ms,b=" + b);
    }

    private static void serial() {
        long start = System.currentTimeMillis();
        int a = 0;
        for (long i = 0; i < count; i++) {
            a += 5;
        }
        int b = 0;
        for (long i = 0; i < count; i++) {
            b--;
        }
        long time = System.currentTimeMillis() - start;
        System.out.println("serial:" + time + "ms,b=" + b + ",a=" + a);
    }
}

3. 减少上下文切换的方法有无锁并发编程、CAS算法、使用最少线程和使用协程。

无锁并发编程。多线程竞争锁时，会引起上下文切换，所以多线程处理数据时，可以用一些办法来避免使用锁，如将数据的ID按照Hash算法取模分段，不同的线程处理不同段的数据。
CAS算法。Java的Atomic包使用CAS算法来更新数据，而不需要加锁。
使用最少线程。避免创建不需要的线程，比如任务很少，但是创建了很多线程来处理，这样会造成大量线程都处于等待状态。
协程：在单线程里实现多任务的调度，并在单线程里维持多个任务间的切换。

4. 减少上下文切换实战

这里我本地没有尝试，用jstack检查线程信息，发现很多线程处于waiting状态。

5. 死锁实例

public class DeadLockDemo {
    private static String A = "A";
    private static String B = "B";

    public static void main(String[] args) {
        new DeadLockDemo().deadLock();
    }

    private void deadLock() {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (A) {
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (B) {
                        System.out.println("1");
                    }
                }
            }
        });

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (B) {
                    synchronized (A) {
                        System.out.println("2");
                    }
                }
            }
        });
        t1.start();
        t2.start();
    }

}

避免死锁的方法

避免一个线程同时获取多个锁。
避免一个线程在锁内同时占用多个资源，尽量保证每个锁只占用一个资源。
尝试使用定时锁，使用lock.tryLock（timeout）来替代使用内部锁机制。
对于数据库锁，加锁和解锁必须在一个数据库连接里，否则会出现解锁失败的情况。”

定时锁lock.tryLock(timeout)使用参考如下代码
如果获取锁失败，就不要一直等着获取了，进入else的代码，或者在else代码中重新尝试获取。

public class LockTest {
    private Lock lock = new ReentrantLock();

    //需要参与同步的方法
    private void method(Thread thread){
        if(lock.tryLock()){
            try {
                System.out.println("线程名"+thread.getName() + "获得了锁");
            }catch(Exception e){
                e.printStackTrace();
            } finally {
                System.out.println("线程名"+thread.getName() + "释放了锁");
                lock.unlock();
            }
        }else{
            System.out.println("我是"+Thread.currentThread().getName()+"有人占着锁，我就不要啦"); 
        }
    }

    public static void main(String[] args) {
        LockTest lockTest = new LockTest();

        //线程1
        Thread t1 = new Thread(()->{
            lockTest.method(Thread.currentThread());
        }, "t1");

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                lockTest.method(Thread.currentThread());
            }
        }, "t2");

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

}

第二章 Java并发机制的底层实现原理

volatile关键字
保证线程间对修饰变量的可见性。在当前线程要修改该变量时，CPU需要从工作内存写回到主内存，其他CPU保存的该变量缓存失效。在汇编中增加了lock。在多CPU开发中，volatile用的好可以代替synchronized，执行成本更低。
Java并发 volatile关键字
synchronized关键字
Synchronized锁偏向锁锁优化
CAS原子操作实现原理

Intel处理器
内存模型如下图所示¹

Java角度
原子类

第三章 Java内存模型

并发编程的艺术 volatile关键字 JMM 重排序

第四章 Java并发编程基础

“现代操作系统在运行一个程序时，会为其创建一个进程。例如，启动一个Java程序，操作系统就会创建一个Java进程。现代操作系统调度的最小单元是线程，也叫轻量级进程（Light Weight Process），在一个进程里可以创建多个线程，这些线程都拥有各自的计数器、堆栈和局部变量等属性，并且能够访问共享的内存变量。处理器在这些线程上高速切换，让使用者感觉到这些线程在同时执行。”
Excerpt From: 方腾飞,魏鹏,程晓明著. “Java并发编程的艺术.” Apple Books.

线程优先级
证明jdk8忽略线程优先级的例子

/**
 * 6-2
 * 证明设置了jdk8忽略了线程优先级
 */
public class Priority {
    private static volatile boolean notStart = true;
    private static volatile boolean notEnd   = true;

    public static void main(String[] args) throws Exception {
        List<Job> jobs = new ArrayList<Job>();
        for (int i = 0; i < 10; i++) {
            int priority = i < 5 ? Thread.MIN_PRIORITY : Thread.MAX_PRIORITY;
            Job job = new Job(priority);
            jobs.add(job);
            Thread thread = new Thread(job, "Thread:" + i);
            thread.setPriority(priority);
            thread.start();
        }
        notStart = false; //此处的作用是让前面的所有线程都休眠，时间未知，等待CPU唤起，notStart指定下达后再一起跑
        Thread.currentThread().setPriority(8);
        System.out.println("done.");
        TimeUnit.SECONDS.sleep(10);
        notEnd = false;

        for (Job job : jobs) {
            System.out.println("Job Priority : " + job.priority + ", Count : " + job.jobCount);
        }

    }

    static class Job implements Runnable {
        private int  priority;
        private long jobCount;

        public Job(int priority) {
            this.priority = priority;
        }

        public void run() {
            while (notStart) {
                Thread.yield();
            }
            while (notEnd) {
                Thread.yield();
                jobCount++;
            }
        }
    }
}

线程状态

整理见这篇博客线程的状态

中断线程

“线程通过检查自身是否被中断来进行响应，线程通过方法isInterrupted()来进行判断是否被中断，也可以调用静态方法Thread.interrupted()对当前线程的中断标识位进行复位。如果该线程已经处于终结状态，即使该线程被中断过，在调用该线程对象的isInterrupted()时依旧会返回false。

从Java的API中可以看到，许多声明抛出InterruptedException的方法（例如Thread.sleep(long millis)方法）这些方法在抛出InterruptedException之前，Java虚拟机会先将该线程的中断标识位清除，然后抛出InterruptedException，此时调用isInterrupted()方法将会返回false。”

Excerpt From: 方腾飞,魏鹏,程晓明著. “Java并发编程的艺术.” Apple Books.

public class Interrupted {

    public static void main(String[] args) throws Exception {
       
        Thread sleepThread = new Thread(new SleepRunner(), "SleepThread");
        sleepThread.setDaemon(true);
        Thread busyThread = new Thread(new BusyRunner(), "BusyThread");
        busyThread.setDaemon(true);
        sleepThread.start();
        busyThread.start();
        TimeUnit.SECONDS.sleep(5);
        sleepThread.interrupt();
        busyThread.interrupt();
        System.out.println("SleepThread interrupted is " + sleepThread.isInterrupted());
        System.out.println("BusyThread interrupted is " + busyThread.isInterrupted());
        TimeUnit.SECONDS.sleep(2);
    }

    static class SleepRunner implements Runnable {
        @Override
        public void run() {
            while (true) {
                try {
                    Thread.sleep(10000);
                } catch (InterruptedException e) {
                    System.out.println("interruptedException");
                }
                //SleepUtils.second(10);
            }
        }
    }

    static class BusyRunner implements Runnable {
        @Override
        public void run() {
            while (true) {
            }
        }
    }
}

优雅的终止线程
建议用第二种方法

“示例在执行过程中，main线程通过中断操作和cancel()方法均可使CountThread得以终止。这种通过标识位或者中断操作的方式能够使线程在终止时有机会去清理资源，而不是武断地将线程停止，因此这种终止线程的做法显得更加安全和优雅。”

Excerpt From: 方腾飞,魏鹏,程晓明著. “Java并发编程的艺术.” Apple Books.

public class Shutdown {
    public static void main(String[] args) throws Exception {
        Runner one = new Runner();
        Thread countThread = new Thread(one, "CountThread");
        countThread.start();
        // “睡眠1秒，main线程对CountThread进行中断，使CountThread能够感知中断而结束”
        TimeUnit.SECONDS.sleep(1);
        countThread.interrupt();

        Runner two = new Runner();
        countThread = new Thread(two, "CountThread");
        countThread.start();
        // “睡眠1秒，main线程对Runner two进行取消，使CountThread能够感知on为false而结束”
        TimeUnit.SECONDS.sleep(1);
        two.cancel();
    }

    private static class Runner implements Runnable {
        private long             i;

        private volatile boolean on = true;

        @Override
        public void run() {
            while (on && !Thread.currentThread().isInterrupted()) {
                i++;
            }
            System.out.println("Count i = " + i);
        }

        public void cancel() {
            on = false;
        }
    }

}

线程间通信
线程间通信

https://blog.csdn.net/java1993666/article/details/77880651 ↩︎

梦想远航

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
并发编程的艺术读书笔记

第一章并发编程的挑战1. 单核CPU分配运行时间给各个线程，实现多线程执行代码。举例：看英文书时某个单词不会，先记住看到书的页数和行数，然后去查单词，查完回到看书状态，相当于上下文切换。2.多线程并不一定比串行执行代码快举例：循环累加的代码，count=10000时，并发比串行执行慢。public class ConcurrencyTest { private static f...
复制链接

扫一扫