多线程和高并发(五)

最新推荐文章于 2024-09-20 15:32:13 发布
最新推荐文章于 2024-09-20 15:32:13 发布
阅读量194 收藏
点赞数
分类专栏： 多线程和高并发 文章标签： locksupport java 多线程和高并发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wardseptember/article/details/111052123
版权

LockSupport

LockSupport是一个线程阻塞工具类，所有的方法都是静态方法，可以让线程在任意位置阻塞，当然阻塞之后肯定得有唤醒的方法。

常用方法：

public static void park(Object blocker); // 暂停当前线程
public static void parkNanos(Object blocker, long nanos); // 暂停当前线程，不过有超时时间的限制
public static void parkUntil(Object blocker, long deadline); // 暂停当前线程，直到某个时间
public static void park(); // 无期限暂停当前线程
public static void parkNanos(long nanos); // 暂停当前线程，不过有超时时间的限制
public static void parkUntil(long deadline); // 暂停当前线程，直到某个时间
public static void unpark(Thread thread); // 恢复当前线程
public static Object getBlocker(Thread t);

  1. park不需要获取某个对象的锁

  2. park和unpark可以实现类似wait和notify的功能，但是并不和wait和notify交叉，也就是说unpark不会对wait起作用，notify也不会对park起作用。

  3. park和unpark的使用不会出现死锁的情况

  4. 相对于线程的stop和resume，park和unpark的先后顺序并不是那么严格。stop和resume如果顺序反了，会出现死锁现象。而park和unpark却不会。

    park和unpark会对每个线程维持一个许可（boolean值）。

    1. unpark调用时，如果当前线程还未进入park，则许可为true
    2. park调用时，判断许可是否为true，如果是true，则继续往下执行；如果是false，则等待，直到许可为true

  5. blocker的作用是在dump线程的时候看到阻塞对象的信息

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;

public class TestLockSupport {
    public static void main(String[] args) {
        Thread t = new Thread(()->{
            for (int i = 0; i < 10; i++) {
                System.out.println(i);
                if(i == 5) {
                    LockSupport.park(); // 无限期暂停当前线程，直到unpark执行
                }
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        t.start();
        LockSupport.unpark(t);
    }
}

面试题

淘宝曾经的面试题1：

实现一个容器，提供两个方法，add、size，写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束

  1. 使用wait、notify
import java.util.ArrayList;
import java.util.List;

/**
 * @author wardseptember
 * @create 2020-07-05 20:30
 */
public class WaitAndNotify {
    volatile List lists = new ArrayList();

    public void add(Object o) {
        lists.add(o);
    }

    public int size() {
        return lists.size();
    }

    static Object lock = new Object();

    public static void main(String[] args) {
        WaitAndNotify waitAndNotify = new WaitAndNotify();
        Thread t2 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("t2 启动");
                if (waitAndNotify.size() != 5) {
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("t2 结束");
                // 通知t1继续执行
                lock.notify();
            }
        });

        Thread t1 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("t1 启动");
                for (int i = 0; i < 10; i++) {
                    waitAndNotify.add(i);
                    System.out.println("add " + i);
                    if (waitAndNotify.size() == 5) {
                        lock.notify();
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        });
        t2.start();
        t1.start();
    }
}
  1. 使用CountDownLatch
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;

/**
 * @author wardseptember
 * @create 2020-07-05 20:30
 */
public class CountDownLatch_Taobao {
    volatile List lists = new ArrayList();

    public void add(Object o) {
        lists.add(o);
    }

    public int size() {
        return lists.size();
    }

    public static void main(String[] args) {
        CountDownLatch countDownLatch1 = new CountDownLatch(1);
        CountDownLatch countDownLatch2 = new CountDownLatch(1);
        CountDownLatch_Taobao latchTaobao = new CountDownLatch_Taobao();
        Thread t2 = new Thread(() -> {
                System.out.println("t2 启动");
                if (latchTaobao.size() != 5) {
                    try {
                        // t2 暂停
                        countDownLatch1.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("t2 结束");
                // 放行t1
                countDownLatch2.countDown();
        });

        Thread t1 = new Thread(() -> {
                System.out.println("t1 启动");
                for (int i = 0; i < 10; i++) {
                    latchTaobao.add(i);
                    System.out.println("add " + i);
                    if (latchTaobao.size() == 5) {
                        // 放行t2
                        countDownLatch1.countDown();
                        try {
                            // t1暂停
                            countDownLatch2.await();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
        });
        t2.start();
        t1.start();
    }
}
  1. 使用LockSupport
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.LockSupport;

/**
 * @author wardseptember
 * @create 2020-07-05 20:30
 */
public class LockSupport_Taobao {
    volatile List lists = new ArrayList();

    public void add(Object o) {
        lists.add(o);
    }

    public int size() {
        return lists.size();
    }

    static Thread t1 = null, t2 = null;

    public static void main(String[] args) {
        LockSupport_Taobao latchTaobao = new LockSupport_Taobao();
        t2 = new Thread(() -> {
                System.out.println("t2 启动");
                if (latchTaobao.size() != 5) {
                    LockSupport.park(t2);
                }
                System.out.println("t2 结束");
                LockSupport.unpark(t1);
        });

        t1 = new Thread(() -> {
                System.out.println("t1 启动");
                for (int i = 0; i < 10; i++) {
                    latchTaobao.add(i);
                    System.out.println("add " + i);
                    if (latchTaobao.size() == 5) {
                        LockSupport.unpark(t2);
                        LockSupport.park(t1);
                    }
                }
        });
        t2.start();
        t1.start();
    }
}
淘宝曾经的面试题2：

写一个固定容量同步容器，拥有put和get方法，以及getCount方法，能够支持2个生产者线程以及10个消费者线程的阻塞调用。

  1. 使用wait和notify/notifyAll来实现
import java.util.LinkedList;
import java.util.concurrent.TimeUnit;

/**
 * @author wardseptember
 * @create 2020-07-05 21:36
 */
public class MyContainer1<T> {
    final private LinkedList<T> list = new LinkedList<>();
    final private int MAX = 10;

    public synchronized void put(T t) {
        while (list.size() == MAX) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        list.add(t);
        this.notifyAll();
    }

    public synchronized T get() {
        T t = null;
        while (list.size() == 0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        t = list.removeFirst();
        this.notifyAll();
        return t;
    }

    public static void main(String[] args) {
        MyContainer1<String> c = new MyContainer1<>();
        // 启动消费者线程
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for(int j = 0; j < 5; j++) {
                    System.out.println(c.get());
                }
            }, "c" + i).start();
        }

        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 启动生产者线程
        for (int i = 0; i < 2; i++) {
            new Thread(() -> {
                for(int j = 0; j < 25; j++) {
                    c.put(Thread.currentThread().getName() + " " + j);
                }
            }, "p" + i).start();
        }
    }
}
  1. 使用ReentrantLock
import java.util.LinkedList;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author wardseptember
 * @create 2020-07-05 21:36
 */
public class MyContainer2<T> {
    final private LinkedList<T> list = new LinkedList<>();
    final private int MAX = 10;
    private Lock lock = new ReentrantLock();
    private Condition producer = lock.newCondition();
    private Condition consumer = lock.newCondition();

    public void put(T t) {
        try {
            lock.lock();
            while (list.size() == MAX) {
                producer.await();
            }
            list.add(t);
            consumer.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public T get() {
        T t = null;
        try {
            lock.lock();
            while (list.size() == 0) {
                consumer.await();
            }
            t = list.removeFirst();
            producer.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
        return t;
    }

    public static void main(String[] args) {
        MyContainer2<String> c = new MyContainer2<>();
        // 启动消费者线程
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for(int j = 0; j < 5; j++) {
                    System.out.println(c.get());
                }
            }, "c" + i).start();
        }

        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 启动生产者线程
        for (int i = 0; i < 2; i++) {
            new Thread(() -> {
                for(int j = 0; j < 25; j++) {
                    c.put(Thread.currentThread().getName() + " " + j);
                }
            }, "p" + i).start();
        }
    }
}

Synchronized和Lock的区别，使用Lock的好处

原始构成

  • synchronized是关键字属于JVM层面

    monitorenter，底层是通过monitor对象来完成，其实wait/notify等方法也依赖于monitor对象，只有在同步块或者方法中才能调用wait/notify等方法

    monitorexit

  • lock是具体类(java.util.concurrent.locks.lock)是api层面的锁

使用方法

synchronized不需要用户去手动释放锁，当synchronized代码执行完后系统会自动让线程释放对锁的占用。

reentrantlock需要用户去手动释放锁，若没有主动释放锁，就有可能导致出现死锁的现象。

等待是否中断

synchronized不可中断，除非抛出异常或者正常运行完成

Reentranlock 可中断：

  1. 设置超时方法 trylock(long timeout, TimeUnit unit)
  2. lockInterruptibly放代码块中，调用interrupt()方法可中断
加锁是否公平

synchronized是非公平锁

reentrantlock可以非公平锁也可以是公平锁，默认为非公平锁。

锁是否可以绑定多个Condition

synchronized不可以

Reentrantlock用来实现分组唤醒需要唤醒的线程们，可以精确唤醒，而不是像synchronized要么随机唤醒一个线程要么唤醒全部线程。

AQS原理

双向链表加一个volatile int state，链表的每一个节点是一个线程。


VarHandle

VarHandle是指向某个对象的引用。可以用于原子性操作。

  • 普通属性也可以通过VarHandle进行原子性操作
  • 比反射快，直接操作二进制码

ThreadLocal

ThreadLocal是线程独有，别的线程不能修改。

ThreadLocal用途

  • 声明式事务，保证同一个Connection

强、软、弱、虚引用

见之前教程引用

软引用，只有在内存不够用时才会被回收，多用于做缓存。

弱引用，只要进行垃圾回收，弱引用就会被回收，多用于容器里面，ThreadLocal是其一个应用例子。weakHashMap

ThreadLocal使用完了，手动remove掉。

虚引用

ConcurrentHashMap

插入效率低一些，查询时效率高。

教程见ConcurrentHashMap详解(基于1.7和1.8)

ConcurrentSkipListMap

是一个有序的并发Map。

CopyOnWriteList

读多写少可用CopyOnWriteList，写时加锁，读时不加锁。

面试题

两个线程交替输出A1B2C3…Z26

  1. 使用LockSupport
import java.util.concurrent.locks.LockSupport;

/**
 * @author wardseptember
 * @create 2020-07-06 16:50
 */
public class LockSupport_Huawei {
    static Thread t1 = null, t2 = null;

    public static void main(String[] args) {
        char[] aI = "1234567".toCharArray();
        char[] aC = "ABCDEFG".toCharArray();

        t1 = new Thread(() -> {
            for (char c : aC) {
                System.out.println(c);
                LockSupport.unpark(t2);
                LockSupport.park();
            }
        }, "t1");

        t2 = new Thread(() -> {
            for (char c : aI) {
                LockSupport.park();
                System.out.println(c);
                LockSupport.unpark(t1);
            }
        }, "t2");
        t1.start();
        t2.start();
    }
}
  1. 使用wait和notify
/**
 * @author wardseptember
 * @create 2020-07-05 20:30
 */
public class WaitAndNotify_Huawei {

    static Object lock = new Object();

    public static void main(String[] args) {
        WaitAndNotify_Huawei waitAndNotify = new WaitAndNotify_Huawei();
        char[] aI = "1234567".toCharArray();
        char[] aC = "ABCDEFG".toCharArray();
        Thread t2 = new Thread(() -> {
            synchronized (lock) {
                for (char c : aC) {
                    System.out.println(c);
                    try {
                        lock.notify();
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                lock.notify();
            }
        });

        Thread t1 = new Thread(() -> {
            synchronized (lock) {
                for (char c : aI) {
                    System.out.println(c);
                    try {
                        lock.notify();
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                lock.notify();
            }
        });
        t2.start();
        t1.start();
    }
}
推荐阅读

欢迎关注我的公众号呦，率先更新内容，并且后续还有一些源码级的免费教程推出。


wardseptember
关注
专栏目录
多线程和高并发的区别
qq_41002779的博客
05-29 5943
“高并发和多线程”总是被被一起提起，给人的感觉好像他们相等，其实 高并发 不等于 多线程 多线程是完成任务的一种方法，高并发是系统运行的一种状态，通过多线程有助于系统承受高并发的状态的实现。 高并发是系统运行过程张遇到的一种“短时间内遇到大量的操作请求” 的情况，主要发生在web系统集中大量访问或者socket端口集中行收到大量请求（例如12306抢票；天猫双十一活动）。该情况...
LockSupport
mingwulipo的博客
03-26 74
LockSupport是一个线程阻塞工具类，所有的方法都是静态方法，可以让线程在任意位置阻塞，当然阻塞之后肯定得有唤醒的方法。 主要有两类方法：park和unpark。 public static void park(); // 无期限暂停当前线程 public static void parkNanos(long nanos); // 暂停当前线程，不过有超时时间的限制 public stati...
清华大牛用4小时终于把多线程与高并发讲完了！
程序员高级码农
08-17 228
前言 牛批了！清华毕业大牛用了4个小时的时间终于把多线程与高并发给讲完了！面试阿里必问的多线程、分布式、高并发都不懂？你拿什么跳槽？拿什么升职加薪？ 下面就给大家介绍，要想把多线程与高并发学会，必须要掌握的那些内容，希望大家能够喜欢！！！ 面试阿里必问的多线程内容 纤程的本质，go语言纤程为什么和线程池有关？ 并发的本质是什么?锁的本质是什么? synchronized关键字的字节码原语？ 无锁、偏向锁、轻量级锁、重量级锁升级过程？ 偏向锁和重量级锁的应用场景？ 自旋锁何时升级重量级锁
多线程和高并发介绍
穿越清华
06-06 3万+
多线程和高并发介绍 文章目录多线程和高并发介绍前言一、什么是多线程？1.多线程介绍2.多线程实现原理？3.白话文解释多线程4.多线程存在的问题二、什么是高并发?1.高并发介绍2.如何提升系统的并发能力三、多线程和高并发总结 前言 本文主要是针对多线程和高并发的概念做了简单的描述，介绍了什么是多线程，什么是高并发，并且对多线程和高并发的关系做了比较描述。 一、什么是多线程？ 1.多线程介绍 什么是多线程，首先看下百度百科对多线程的定义；多线程（multithreading）
【多线程与高并发】- 浅谈volatile
qq_43843951的博客
02-24 21万+
volatile是Java语言中的一种轻量级的同步机制，它可以确保共享变量的内存可见性，也就是当一个线程修改了共享变量的值时，其他线程能够立即知道这个修改。
【多线程与高并发】- synchronized锁的认知
热门推荐
qq_43843951的博客
02-19 23万+
synchronized 是 Java 语言的一个关键字，它允许多个线程同时访问共享的资源，以避免多线程编程中的竞争条件和死锁问题。
[并发概念] 多线程与高并发
大唐雨夜的博客
12-31 1594
多线程的理解 什么是多线程 如果一个程序允许两个或者两个以上的线程，那么它便是多线程程序。多线程是指单个进程内允许多个线程。 任务分为资源独立任务和资源共享任务。独立任务不需要使用多线程；共享任务，会使用到进程共享资源，需要保证线程安全。 场景理解：房子与租客 假设有一套房子，住着我和我的几个室友，房子比喻进程，我和室友比喻线程。房子中有很多公共空间，例如厨房、客厅，每个人都可以到客厅来。厨房和客...
多线程和高并发的常见面试题整理
zhangqiang180的博客
07-12 7817
1.线程实现方式 1继承Thread类 定义Thread类的子类，并重写Thread类的run()方法，创建子类对象（即线程对象），调用线程对象的start()方法来启动该线程 2.实现Runnable接口 并重写该接口的run()方法，该run()方法同样是该线程的执行体。创建该Runnable实现类的实例，并将此实例作为Thread的target（即构造函数中的参数）来创建Thread对象（该Thread对象才是真正的线程对象，只是该Thread对象负责执行其target的run()方法）。最后调用线程
什么是多线程和高并发
刘鹏博的博客
06-30 1938
  “高并发和多线程”总是被一起提起，给人感觉两者好像相等，实则 高并发 ≠ 多线程　　多线程是完成任务的一种方法，高并发是系统运行的一种状态，通过多线程有助于系统承受高并发状态的实现。　  高并发是一种系统运行过程中遇到的一种“短时间内遇到大量操作请求”的情况，主要发生在web系统集中大量访问或者socket端口集中性收到大量请求（例如：12306的抢票情况；天猫双十一活动）。该情况的发生会导致...
多线程高并发编程MySQL数据库处理
小坚的技术博客
08-10 4606
本文作者：陈进坚 个人博客：https://jian1098.github.io CSDN博客：https://blog.csdn.net/c_jian 简书：https://www.jianshu.com/u/8ba9ac5706b6 联系方式：jian1098@qq.com 摘要 ​ 现在很多主流的编程语言都支持多线程或者协程处理，例如天生支持协程的go语言、php+swoole等。但是多线程和单线程不同，多线程如果不对数据库做处理的话，有时候单线程跑的程序没有问题，但是一旦开启多线程，数据库就.
多线程，高并发.pdf
08-15
1. stop() 和 suspend() 方法为何不推荐使用？ 2. sleep() 和 wait() 有什么区别? 3. 同步和异步有何异同，在什么情况下分别使用他们？ 4. 当一个线程进入一个对象的一个 synchronized 方法后，其它线程是否可进入此...
多线程与高并发-电子.pdf
05-03
多线程与高并发是计算机科学中非常重要的两个概念，它们在提高软件程序的性能、响应速度和资源利用率方面起着至关重要的作用。在当今的互联网时代，特别是在产业互联网和5G技术的推动下，多线程和高并发的应用变得...
多线程源码JUC以及多线程和高并发
01-22
多线程源码JUC以及多线程和高并发 https://blog.csdn.net/u011488009 主要是根据 https://blog.csdn.net/u011488009/category_9678616.html 专栏来讲解的源码，都可以作为高并发的学习，练手用，主要是看这个源码...
人工智能-项目实践-多线程-多线程与高并发.zip
01-04
在IT领域，尤其是在人工智能（AI）的项目实践中，多线程和高并发是两个至关重要的概念，它们对于提升系统性能和处理大规模数据流至关重要。在这个名为"人工智能-项目实践-多线程-多线程与高并发.zip"的压缩包中，...
Java-网络
2301_81543552的博客
09-14 791
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
Java企业面试题3
m0_74972727的博客
09-15 825
1. break和continue的作用(智*图) break：用于完全退出一个循环（如 for, while）或一个 switch 语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。 continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在 for 循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。 2. if分支语句和switch分支语句的异同之处(智*图) 相同点：都是用来根据不同的条件执行不同的代码块。
上传文件到钉盘流程详解
jspyth的博客
09-14 811
本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。
JDK17新增语法特性
最新发布
2201_76124988的博客
09-20 337
从springboot3.0开始，已经不支持JDK8，转变为JDK17参考资料：官方博客。
java 多线程和高并发
07-27
- *1* *2* *3* [Java的多线程和高并发详解](https://blog.csdn.net/linuxguitu/article/details/118368537)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值