走入并行世界 读书笔记

最新推荐文章于 2024-11-13 20:43:20 发布
最新推荐文章于 2024-11-13 20:43:20 发布
阅读量437 收藏 1
点赞数 1
分类专栏： 线程-java 文章标签： java 线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zp437734552/article/details/78605030
版权
一、JMM：Java Memory Model(Java内存模型)
  • 1.1原子性
    操作不可中断
  • 1.2可见性
    共享变量的修改，其他线程是否能够立即知道这个修改
  • 1.3有序性
二、java并行程序基础
Theard案例
class MyThread extends Thread {

    @Override
    public void run() {
       do something...
    }
}
MyThread mt = new MyThread("thread name");
mt.start();
Runnable案例
class MyRunnable implements Runnable {

    @Override
    public void run() {
        do something...
    }
}
MyRunnable mt = new MyRunnable();
Thread td = new Thread(mt, "thread name");
td.start();
并发中的List
  • 异常问题：
    ArrayList al = new ArrayList(10);
    如果多个线程add数据，ArrayList扩容有些时候会越界
  • 解决：
    使用Vector，不过性能不好
    使用CopyOnWriteArrayList，读多写少下，性能非常好
    使用ConcurrentLinkedQueue，高效并发队列，线程安全的LinkedList
并发中的Map
  • HashMap，java8解决了
  • 其他的话，用ConcurrentHashMap线程安全的hashMap
三、线程操作
新建
start()
终止
自己定义一个boolean值，不要用stop()方法
睡眠 + 中断（一般用于线程中断的异常操作）

  • Thread.interrupt() # 中断线程，但是如果没有后续逻辑，它其实没有操作什么

    
/**
 * 线程中断测试
 */
public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread() {
        @Override
        public void run() {
            // 循环监控
            while(true) {
                if (Thread.currentThread().isInterrupted()) {
                    System.out.println("线程中断");
                    break;
                }
                try {
                    Thread.sleep(2000);
                    System.out.println("子线程执行中");
                } catch (InterruptedException e) {
                    System.out.println("当前线程睡眠被中断");    
                    // 不设置中断，则下一次循环无法捕获，所以还需要设置中断标记
                    Thread.currentThread().interrupt(); 
                }
            }
        }
    };
    t1.start(); // 子线程执行中
    Thread.sleep(5000); // 主线程睡眠5秒
    t1.interrupt(); // 强制中断子线程
}

console:
    子线程执行中
    子线程执行中
    当前线程睡眠被中断
    线程中断
等待和通知（Object类），下面的join方法就是用的这些，所以少用wait和notify，直接用join即可
  • wait、notify、notifyAll
  • 必须包含在对应的synchronized语句中，必须获得目标对象的一个监视器

  • sleep不会释放锁，wait会释放

    public class ThreadTest {
    // 锁
    final static Object obj = new Object();

    public static class T1 extends Thread{
        @Override
        public void run() {
            synchronized (obj){
                System.out.println(System.currentTimeMillis() + " T1 start");
                try {
                    System.out.println(System.currentTimeMillis() + " T1 wait from obj");
                    obj.wait(); // 等待
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(System.currentTimeMillis() + "T1 end");
            }
        }
    }

    public static class T2 extends Thread{
        @Override
        public void run() {
            synchronized (obj){
                System.out.println(System.currentTimeMillis() + " T2 start!notify one thread");
                obj.notify(); // 唤起，必须是同一个obj锁内
                System.out.println(System.currentTimeMillis() + " T2 end!");
                try {
                    Thread.sleep(2000); // 睡眠2秒，不放开锁
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) { // ti不一定先执行，多执行几次
        Thread t1 = new T1();
        t1.start();
        Thread t2 = new T2();
        t2.start();
    }
}

console:
    151125703 2560 T1 start
    151125703 2560 T1 wait from obj
    151125703 2560 T2 start!notify one thread
    151125703 2560 T2 end!
    151125703 4560 T1 end //T2输出了end以后sleep了2秒，所以sleep并不会释放锁
等待线程结束join和谦让yield

  • join，等待线程完成再执行

    public volatile static int i = 0; // 同步参数

public static class AddThread extends Thread {
    @Override
    public void run() {
        for (i = 0; i < 1000000; i++) ;
    }
}

public static void main(String[] args) throws InterruptedException {
    Thread t = new AddThread();
    t.start();
    t.join();               // 如果没有join方法，主线程就已经打印i了；现在需要等t线程完成再打印
    System.out.println(i);
}
  • yield，当前线程让出cpu，重新进行竞争
    做完重要的事情了，然后让出cpu，给其他线程一些机会
    或者优先级低，怕它占用太多cpu资源，适当的时候使用yield方法
  • volatile
    它只能保证一个线程修改了数据后，其他线程能够看到这个改动，2个线程如果同时修改某一个数据时，依然会产生冲突
线程组
  • 能管理一组线程，比如中断、销毁、停止、优先级等，但是不能同时启动
    @Override
    public void run() {
        String groupAndName = Thread.currentThread().getThreadGroup().getName() +
                "-" + Thread.currentThread().getName();
        while(true){
            System.out.println("I am " + groupAndName);
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        ThreadGroup tg = new ThreadGroup("PrintGroup");
        Thread t1 = new Thread(tg, new thisClass(), "name1");
        Thread t2 = new Thread(tg, new thisClass(), "name2");
        t1.start();
        t2.start();
        // activeCount 估计线程总数，因为线程是动态的
        System.out.println(tg.activeCount()); 
        tg.list(); // 打印组内所有线程信息
    }
守护线程
  • t.start()前设置： t1.setDaemon(true);
  • 用户线程结束了，守护线程自动就结束了，所以不要用在类似于IO这样的线程中
  • 见过的比如 垃圾回收、数据库线程数量监控等等，eg：如果想main结束，线程就结束，可以设置为守护线程
优先级
  • 各个平台表现不一，不严格，有效为1-10
  • t.setPriority(Thread.MAX_PRIORITY);
  • t.setPriority(Thread.MIN_PRIORITY);
  • 或者直接输入1-10
线程池
  • newFixedThreadPool 返回固定线程数量的线程池
  • newCachedThreadPool 可变数量
  • 还有2个是定时执行的，暂时不看了
public static class MyTask implements Runnable{
        @Override
        public void run() {
            System.out.println(System.currentTimeMillis() + ":Thread ID:"
             + Thread.currentThread().getId());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        MyTask task = new MyTask();
        // 只有5个线程，处理完5个sleep2秒返回线程池，再用这5个
        ExecutorService es = Executors.newFixedThreadPool(5);
        // 直接扩充成10个线程了
//        ExecutorService es = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++){
            es.submit(task);
            // es.execute(task); // 如果线程输出缺失，这个替换submit能查看到堆栈信息
        }
    }
  • 自定义线程
    /**
     * int corePoolSize     核心线程数，一直存活
     * int maximumPoolSize  最大线程，超出会进入拒绝策略
     * long keepAliveTime   空闲时间，超过则退出线程
     * TimeUnit unit        空闲时间单位
     * WorkQueue<Runnable> workQueue    任务队列（常用3个，见下）
     * RejectedExecutionHandler handler     拒绝任务的处理策略（4个，见下）
     *      
     * 以下参数顺序同上
     */
    ......
        ThreadPoolExecutor es = new ThreadPoolExecutor(10, 100, 10, TimeUnit.SECONDS,
            new ArrayBlockingQueue<Runnable>(10),
            new ThreadPoolExecutor.DiscardPolicy());
    ......
- 任务队列
    - 它是一个BlockingQueue接口的对象
    - SynchronousQueue 直接提交的队列，不真实保存数据，当线程池满了就执行拒绝策略，所以一般将最大线程数量设置很大
    - ArrayBlockingQueue，有界队列，核心线程满了，进入队列，顺序保存数据
    - LinkedBlockingQueue，无界队列，核心线程满了，进入队列，不会失败，无限，直到耗尽内存
    - PriorityBlockingQueue，优先任务队列，无界，在确保性能的同时，能保证质量
- 拒绝策略
    - AbortPolicy   抛出异常，阻止运行
    - CallerRunsPolicy  运行当前被丢弃的任务，性能可能会极具下降
    - DiscardOldestPolicy   抛弃最老的任务
    - DiscardPolicy     抛弃无法处理的任务，如果允许任务丢失，这个是最好的
  • 自定义线程二（一般不用自己创建，使用默认的即可）
    同自定义线程，不过可以不用它的策略，自己扩展策略或者使用线程工厂自定义线程池
    ......
    ExecutorService es = new ThreadPoolExecutor(5, 5, 0L, TimeUnit.MILLISECONDS,
                new SynchronousQueue<Runnable>(),
                new ThreadFactory() {
                    @Override
                    public Thread newThread(Runnable r) {
                        Thread t = new Thread(r);
                        // t.setDaemon(true); // 可以设为守护线程
                        System.out.println("create " + t);
                        return t;
                    }
                }
    );
    ......
  • 最优线程池
    • Ncpu = CPU的数量 System.out.println(Runtime.getRuntime().availableProcessors());
    • Ucpu = 目标CPU的使用率， 0 <= Ucpu <= 1
    • W/C = 等待时间 与 计算时间的比率
    • Nthreads = Ncpu * Ucpu * ( 1 + W/C )
    • 我拿我的计算机进行了测试
四、同步 synchronized
  • 必须是同一对象锁（int行，Integer不行，++操作以后Integer是个新对象）

  • 总结用法：

    • 对象锁
    • 直接作用于实例方法

    • 直接作用于静态方法 

      public class ThreadTest implements Runnable {
    static ThreadTest tt = new ThreadTest();
    static int i = 0;

    @Override
    public void run() {
        synchronized (tt) { // 如果不同步，则i会被同时写入，造成实际 <200000
            for (int j = 0; j < 100000; j++) {
                i++;
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(tt); // 注意！必须是同一个对象
        Thread t2 = new Thread(tt); // 注意！必须是同一个对象

        t1.start();t2.start();
        t1.join();t2.join();
        System.out.println(i);
    }
}

    • 另一种写法，抽出同步代码块，变成同步方法/同步静态方法

      public synchronized void increase(){ // static也一样
    for (int j = 0; j < 100000; j++) {
        i++;
    }
}
@Override
public void run() {
    increase();
}

  • 优化建议

    • jdk6以后synchronized和lock性能非常接近了，用哪个都行，就是读写锁感觉很有用
    • 减少持有时间
      尽量减少同步的方法
    • 减少锁粒度
      不用考虑太多，除非调用少才合适
    • 读写分离锁来替换独占锁
    • 锁分离
    • 锁粗化
      串行的很多锁可以合并为块，开关锁也是要消耗资源的，例如for循环内部的锁不如外部一并加锁
    • 读写锁案例： 
          public class ReadWriteLockDemo {
        // 原来的锁
        private static Lock lock = new ReentrantLock();

        // 创建读、写锁
        private static ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
        private static Lock readLock = readWriteLock.readLock();
        private static Lock writeLock = readWriteLock.writeLock();

        // 读取的参考变量
        private int value;

        // 模拟读方法
        public Object handleRead(Lock lock) throws InterruptedException {
            System.out.println(Thread.currentThread().getName() + "-read-begin");
            try {
                lock.lock(); // 模拟读操作
                Thread.sleep(2000); // 读操作耗时越多越明显；线程（除了被写占用的线程）会一并进入方法，然后各读各的，各返回各的
                return value;
            } finally {
                lock.unlock();
                System.out.println(Thread.currentThread().getName() + "-read-end");
            }
        }

        // 模拟写方法
        public void handleWrite(Lock lock, int index) throws InterruptedException {
            System.out.println(Thread.currentThread().getName() + "-write-begin");
            try {
                lock.lock();
                Thread.sleep(1000);
                value = index;
            } finally {
                lock.unlock();
            }
            System.out.println(Thread.currentThread().getName() + "-write-end");
        }

        public static void main(String[] args) {
            final ReadWriteLockDemo demo = new ReadWriteLockDemo();

            // 模拟读线程
            Runnable readRunnale = new Runnable() {
                @Override
                public void run() {
                    try {
                        // 用了读锁，所有的读线程会一起进入，相互不阻塞
                        demo.handleRead(readLock);
                        // 用普通的锁，会一个一个进入
    //                    demo.handleRead(lock);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            };
            Runnable writeRunnale = new Runnable() {
                @Override
                public void run() {
                    try {
                        // 用了写锁，和普通的lock一样，是阻塞的
                        demo.handleWrite(writeLock, new Random().nextInt());
    //                    demo.handleWrite(lock, new Random().nextInt());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            };

            for (int i = 0; i < 18; i++){
                new Thread(readRunnale).start();
            }
            for (int i = 18; i < 20; i++){
                new Thread(writeRunnale).start();
            }
        }
}
五师弟
关注
专栏目录
并行学习总结
benpaobagzb的博客
02-22 1万+
Thread的提出有一部分原因就是来因为IPC效率低下，像这样使用多进程仅仅是把本来应该自己做的同步交给了OS去完成。而且最终数据要汇集到一个进程去最终完成，这样的话效率最终很可能就被这最后一个进程限制住，从而影响了整体的效率。 所以采用进程中开多个线程来提高通信效率避免进程间通信效率低下的问题，再把每个线程绑定到每个核上去就可以避免线程切换带来的开销弊端。再开多个进程进而把所有的核都利用起来（
1.走入并行世界
m0_37681974的博客
10-09 112
开始学习《实战java高并发程序设计》，记录学习笔记。 1.一些概念 1.同步和异步 2.并发和并行 3.临界区 4.阻塞和非阻塞 5.死锁，饥饿和活锁 2.并发的级别 1.阻塞 2.无饥饿 3.无障碍 4.无锁 5.无等待 3.并行的两个重要定律 1.Amdahl定律 2.Gustafson定律 4.Java内存模型 1.原子性 2.可见性 3.有序性 ...
《并行程序设计导论》读书笔记( chapter1 )
BOTAK
06-17 472
why ? 为什么要编写并行程序与构建并行系统 The answer：单处理器的性能具有瓶颈，内部原因是因为晶体管的密度不可能无限制的增大，外部原因是因为密度增大，处理器的散热就是一个很大的问题，过于高的温度会影响性能。 how ? Two methods：任务并行与数据并行 在这里，用一个简单的例子来说明任务并行与数据并行之间的区别：现在有一个教授P，然后他的手下有4个助教（A,B,C,D），期...
《并行程序设计导论》Peter S.Pacheco 读书笔记
Honkee_的专栏
08-29 5337
最近读了《并行程序设计导论》这本书。感觉这本书讲的东西
《实战 Java 高并发程序设计》笔记——第1章 走入并行世界（一）
bm1998
12-18 250
文章目录1.1 何去何从的并行计算1.1.1 忘掉那该死的并行1.1.2 可怕的现实：摩尔定律的失效1.1.3 柳暗花明：不断地前进1.1.4 光明或是黑暗1.2 你必须知道的几个概念1.2.1 同步（Synchronous）和异步（Asynchronous）1.2.2 并发（Concurrency）和并行（Parallelism）1.2.3 临界区1.2.4 阻塞（Blocking）和非阻塞（Non-Blocking）1.2.5 死锁（Deadlock）、饥饿（Starvation）和活锁（Liveloc
【读书笔记】面试为什么总考算法_如何避开算法面试
Keep Reading Keep Writing Keep Thinking
12-10 308
持续学习&持续更新中… 守破离 程序员技术指北—面试为什么总考算法_如何避开算法面试面试为什么总考算法如何避开算法面试参考 面试为什么总考算法 大厂面试究竟为什么总是考算法？ 很多同学都问过我这个问题，毕竟，在实际工作中，我们近乎根本不可能从底层实现一遍经典算法。我曾经在我的公众号文章《学算法有什么用？没用》中说过，如果真的以工作内容为导向，算法还真可能对绝大部分同学来说没什么用。 但是，算法却是大厂面试考察的重点。甚至，极端一些，国外一些大厂只考算法。 为什么会这样？在这篇文章中，我打算系.
实战Java高并发程序设计》笔记
张学友
06-29 178
《实战Java高并发程序设计》笔记 Linus:The only place where parallelism matters is in graphical or the server side,where we already largely have it. Pushing it anywhere is just pointless 一 走入并行世界 1.2 你必须知道的几个概念: 同步和异步 同步:同步调用一旦开始,调用者必须等到方法返回后才能继续后续的行为 异步:异步方法更像一个消息传递,
NLP新闻文本分类比赛学习笔记
qq_45507598的博客
07-21 473
NLP新闻文本分类比赛学习笔记NLP赛事 - Task1 赛题理解赛题理解解题思路 NLP赛事 - Task1 赛题理解 赛题理解 赛题名称：零基础入门NLP之新闻文本分类 赛题目标：通过这道赛题可以引导大家走入自然语言处理的世界，带大家接触NLP的预处理、模型构建和模型训练等知识点。 赛题任务：赛题以自然语言处理为背景，要求选手对新闻文本进行分类，这是一个典型的字符识别问题。 赛题数据 赛题以匿名处理后的新闻数据为赛题数据，数据集报名后可见并可下载。赛题数据为新闻文本，并按照字符级别进行匿名处理。整合划
走入并行世界
Mason的博客
07-20 195
并发偏重于多个任务交替执行，多个任务之间可能串行，并行是真正意义上的同时执行,真实的并行只能出现在多核CPU，因为一个cpu只能执行一个任务 无障碍 无障碍是一种最弱的非阻塞调度，对于无障碍的线程来说，一但检测到一起修改共享数据，就会立即对自己所做的修改进行回滚，确保数据安全，没有数据竞争，线程顺利完成自己的工作，走出临界区。任何对资源有修改操作的线程，在修改数据前，都需要更新这个一致性标记，
（一）走入并行世界
qq_35599414的博客
05-06 216
第一章 走入并行世界 一、必知的概念 1、同步和异步 同步：串行化的执行，前面A执行完成才能执行后面B的。（需要前面的执行返回结果才开始后面的操作） 异步：执行操作A的同时，去执行操作B。不需要等A操作完返回结果再去操作B。此时利用多线程执行多个操作。 2、并发和并行 并发：多个任务交替执行，利用多线程实现（多个线程间互相切换执行），非真正意义上的同步进行，而是因为线程切换快执行快从而体现的"同时执行"的效果。（一个进程内其实只能有一个线程在运行） 并行：真正的同时执行，多个进程同时执行
并发知识体系大全：贡献一波我平时学习/总结笔记/思维脑图+线程
msbz7的博客
10-27 104
在并发底层原理中，不仅涉及 Java 语言，更涉及 JVM、操作系统、内存、CPU 指令等，令人一头雾水。这个世界都是并发的，编程里更是这样，俗话说：并发知识大，一口吃不下。很多程序员，整天沉浸在业务代码的 CRUD 中，业务中没有大量数据做并发，缺少实战经验，对并发仅仅停留在了解，做不到精通，所以总是与大厂擦肩而过。我把私藏的这套并发体系的笔记和思维脑图分享出来，理论知识与项目实战的结合，我觉得只要你肯花时间用心学完这些，一定可以快速掌握并发编程。让每一个工具类，成为你并发知识体系中的一块块“拼图”。
Servlet的生命周期
最新发布
wyk的博客
11-13 803
Servlet 的生命周期包含四个主要阶段：加载与实例化、初始化、请求处理、销毁。开发者可以在这些生命周期方法中编写初始化、请求处理和资源清理的代码，确保 Web 应用程序的正常运行。
日常bug记录，easyexcel导入报错convert data ... to class java.math.BigDecimal error
mm
11-11 244
排查发现实体类中有BigDecimal属性，然而数据中这个属性为null，进行转换时报错。在实体类上加上自定义转换器。解决方法：自定义转换器类。
1112--接口
kequanrrr的博客
11-12 362
interface + 接口名{ }。。。。implements 接口名{ }接口：接口中的抽象方法可以省略 abstract 关键字使用：要实现接口中的所有 抽象方法隐含三个修饰符：public+static+final2.单继承 多接口。
SpringBoot(五)
₍˄·͈༝·͈˄*₎◞ ̑̑的博客
11-13 639
Rest请求处理
JAVA学习接口案例实例
shangan_3的博客
11-08 231
【代码】JAVA学习接口案例实例。
深入理解Java的类加载与卸载机制
Luffy的博客
11-12 854
类加载是指JVM将.class文件中的二进制数据读入内存中，经过一系列验证、解析和初始化，最终在JVM中生成可以被使用的Class对象。JVM会为每个类加载并生成一个唯一的Class对象，这个对象封装了类的所有信息，包括方法、属性等。类加载的三大步骤：1.加载（Loading）：从不同的源（如文件、网络）获取类的二进制字节码，并生成Class对象。2.链接（Linking）：对类的二进制进行校验和解析，确保类文件格式正确。验证（Verification）：检查字节码是否符合JVM的规范。
ArkTS--应用状态
qq_63946637的博客
11-10 625
本文旨在帮助大家学习鸿蒙中的LocalStorage和AppStorage
JavaScript 高阶总结
qq_43787947的博客
11-11 886
JavaScript 高级总结
C++接口类， 抽象类和实体类简述
Joshua的专栏
11-09 335
在C++中，接口类通常是指只包含纯虚函数（pure virtual functions）的类。接口类的主要目的是定义一组通用的行为，但不提供任何具体的实现。通过上述示例可以看出，C++通过抽象类和多重继承实现了类似Java中的单一实体继承和多接口继承的效果。在C++中，虽然没有像Java那样明确的“接口”关键字，但可以通过抽象类和纯虚函数来实现接口的概念。实体类是指可以实例化的类，即类中所有的函数都有具体的实现，包括继承自抽象类的纯虚函数。单实体继承（多接口继承）的设计理念和好处。类继承和接口继承的比较。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值