【线程安全、volatile关键字、原子性、并发包、死锁、线程池】

最新推荐文章于 2022-05-26 15:55:19 发布
最新推荐文章于 2022-05-26 15:55:19 发布
阅读量140 收藏
点赞数
分类专栏： java基础 java学习 文章标签： java 线程池 线程安全
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43956936/article/details/115915761
版权

1、线程安全

1.1线程安全

当多个线程访问某个方法时，不管你通过怎样的调用方式、或者说这些线程如何交替地执行，我们在主程序中不需要去做任何的同步，这个类的结果行为都是我们设想的正确行为，那么我们就可以说这个类是线程安全的。

例：电影院要卖票，我们模拟电影院的卖票过程。假设要播放的电影是 “奥特曼”，本次电影的座位共100个(本场电影只能卖100张票)。共有四个窗口同时卖票。

public class MyRunnable implements Runnable {
    int tickets = 100;// 4个窗口共同卖的票 共享变量
    @Override
    public void run() {
        // 实现卖票的操作
        // 死循环卖票
        while (true){
            // 当票卖完了,就结束
            if (tickets < 1){
                break;
            }
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+":正在出售第"+tickets+"张票");
            tickets--;
        }
    }
}

public class Test {
    public static void main(String[] args) {
        // 电影院4个窗口  去卖票
        MyRunnable mr = new MyRunnable();
        Thread t1 = new Thread(mr,"窗口1");
        Thread t2 = new Thread(mr,"窗口2");
        Thread t3 = new Thread(mr,"窗口3");
        Thread t4 = new Thread(mr,"窗口4");

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

运行截图：
在这里插入图片描述发现程序出现了两个问题：

  1. 相同的票数,比如100这张票被卖了四回。
  2. 不存在的票，比如0票与-1票,-2票，是不存在的。

这种问题，几个窗口(线程)票数不同步了，这种问题称为线程不安全。

1.2、synchronized关键字

synchronized关键字：表示“同步”的。**它可以对“多行代码”进行“同步”——将多行代码当成是一个完整的整体，一个线程如果进入到这个代码块中，会全部执行完毕，执行结束后，其它线程才会执行。**这样可以保证这多行的代码作为完整的整体，被一个线程完整的执行完毕。

synchronized有几种使用方式：
a).同步代码块
b).同步方法【常用】

1.2.1、同步代码块

格式：

synchronized(同步锁){
     需要同步操作的代码
}

同步锁:

对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁.

  1. 锁对象 可以是任意类型。
  2. 多个线程对象 要使用同一把锁。

注意:在任何时候,最多允许一个线程拥有同步锁,谁拿到锁就进入代码块,其他的线程只能在外等着(BLOCKED)。

卖票问题

public class MyRunnable implements Runnable{
    int tickets = 100;
    @Override
    public void run() {
        while (true){
            //同步代码块
            synchronized (this){
                if(tickets < 1){
                    break;
                }
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+":正在出售第"+tickets+"张票");
                tickets--;
            }
        }
    }
}
1.2.2、同步方法
  • 同步方法:使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。

格式：

public synchronized void method(){
   	可能会产生线程安全问题的代码
}

同步锁是谁?

​ 对于非static方法,同步锁就是this。

​ 对于static方法,我们使用当前方法所在类的字节码对象(类名.class)。

卖票问题

public class MyRunnable1 implements Runnable{
    int tickets = 100;

    @Override
    public void run() {
        while (true){
            //加锁
            if (sellTickets()) break;
        }
    }

    private synchronized boolean sellTickets() {
        if (tickets < 1) {
            return true;
        }
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ":正在出售第" + tickets + "张票");
        tickets--;
        return false;
    }
}

1.3、Lock锁

java.util.concurrent.locks.Lock机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作,同步代码块/同步方法具有的功能Lock都有,除此之外更强大

Lock锁也称同步锁，加锁与释放锁方法化了，如下：

  • public void lock():加同步锁。
  • public void unlock():释放同步锁。

使用如下：

public class MyRunnable2 implements Runnable{
    int tickets = 100;
    Lock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true){
            //加锁
            lock.lock();
            if (tickets < 1) {
                return;
            }
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ":正在出售第" + tickets + "张票");
            tickets--;
            //释放锁
            lock.unlock();
        }
    }
}

2、高并发及线程安全

  • 高并发：是指在某个时间点上，有大量的用户(线程)同时访问同一资源。例如：天猫的双11购物节、12306的在线购票在某个时间点上，都会面临大量用户同时抢购同一件商品/车票的情况。
  • 线程安全：在某个时间点上，当大量用户(线程)访问同一资源时，由于多线程运行机制的原因，可能会导致被访问的资源出现"数据污染"的问题。

  • 2.1、多线程的运行机制

  • 当一个线程启动后，JVM会为其分配一个独立的"线程栈区"，这个线程会在这个独立的栈区中运行。
  • 多个线程在各自栈区中独立、无序的运行，当访问一些代码，或者同一个变量时，就可能会产生一些问题

2.2、多线程的安全性问题-可见性

概述: 一个线程没有看见另一个线程对共享变量的修改
例如，先启动一个线程，在线程中将一个变量的值更改，而主线程却一直无法获得此变量的新值。

public class Demo {
    private static boolean flag = false;

    public static void main(String[] args) throws InterruptedException {
        new Thread(){
            @Override
            public void run() {
                while (!flag){}
                System.out.println("循环结束");
            }
        }.start();
        System.out.println(new Date()+"main线程开启");
        Thread.sleep(3000);
        flag = true;
        System.out.println(new Date() + "main 线程设置 flag 为:" + flag);
    }
}

  • 分析结果应该是: 主线程把共享变量flag改为true,然后子线程的死循环就可以结束

  • 实际结果是:主线程把共享变量flag改为true,但子线程依然是死循环

  • 原因:

  • Java内存模型(Java Memory Model)描述了Java程序中各种变量(线程共享变量)的访问规则，以及在JVM中将变量存储到内存和从内存中读取变量这样的底层细节。

  • 简而言之: 就是所有共享变量都是存在主内存中的,线程在执行的时候,有单独的工作内存,会把共享变量拷贝一份到线程的单独工作内存中,并且对变量所有的操作,都是在单独的工作内存中完成的,不会直接读写主内存中的变量值。

2.3、知识点-- 多线程的安全性问题-有序性

  • 有些时候“编译器”在编译代码时，会对代码进行“重排”，例如：
          int a = 10;     //1

  ​        int b = 20;     //2

  ​        int c = a + b;   //3

第一行和第二行可能会被“重排”：可能先编译第二行，再编译第一行，总之在执行第三行之前，会将1,2编译完毕。1和2先编译谁，不影响第三行的结果。

  • 但在“多线程”情况下，代码重排，可能会对另一个线程访问的结果产生影响。

2.4、多线程的安全性问题-原子性

  • 概述：所谓的原子性是指在一次操作或者多次操作中，要么所有的操作全部都得到了执行并且不会受到任何因素的干扰而中断，要么所有的操作都不执行，多个操作是一个不可以分割的整体。

  • 请看以下示例：

    • 一条子线程和一条主线程都对共享变量a进行++操作,每条线程对a++操作1000次
public class Demo{
    public static int a = 0;
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 10000; i++) {
                    a++;
                }
            }
        };
        Thread t2 = new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 10000; i++) {
                    a++;
                }
            }
        };
        t1.start();
        t2.start();
        t1.join();
        t2.join();

        System.out.println(a);
    }
}
  • 预期：20000
  • 实际：可能出现异常，以及数字没达到20000
  • 原因：两个线程对共享变量的操作产生覆盖的效果

3、volatile关键字

  • volatile是一个"变量修饰符"，它只能修饰成员变量，它能强制线程每次从主内存获取值，并能保证此变量不会被编译器优化。
  • volatile能解决变量的可见性、有序性；
  • volatile不能解决变量的原子性

3.1、volatile解决可见性

public class Demo{
    private static volatile boolean flag = false;
    public static void main(String[] args) throws InterruptedException {
        new Thread(){
            @Override
            public void run() {
                while (!flag){}
                System.out.println("循环结束");
            }
        }.start();
        System.out.println(new Date()+"main线程开启");
        Thread.sleep(3000);
        flag = true;
        System.out.println(new Date() + "main 线程设置 flag 为:" + flag);
    }
}

flag修改，循环结束
当变量被修饰为volatile时，会迫使线程每次使用此变量，都会去主内存获取，保证其可见性

3.2、volatile解决有序性

  • 当变量被修饰为volatile时，会禁止代码重排。

4、原子类

在java.util.concurrent.atomic包下定义了一些对“变量”操作的“原子类”:

​ 1).java.util.concurrent.atomic.AtomicInteger：对int变量操作的“原子类”;

​ 2).java.util.concurrent.atomic.AtomicLong：对long变量操作的“原子类”;

​ 3).java.util.concurrent.atomic.AtomicBoolean：对boolean变量操作的“原子类”;

它们可以保证对“变量”操作的：原子性、有序性、可见性。

5、并发包

5.1、CopyOnWriteArrayList、CopyOnWriteArraySet、ConcurrentHashMap

  • CopyOnWriteArrayList、CopyOnWriteArraySet、ConcurrentHashMap线程安全
public class H31 {
    public static void main(String[] args) throws InterruptedException {
        CopyOnWriteArrayList<Integer> list = new CopyOnWriteArrayList<>();

        Thread t1 = new Thread() {
            @Override
            public void run() {
                for (int i = 1; i <= 10000; i++) {
                    list.add(i);
                }
            }
        };

        Thread t2 = new Thread() {
            @Override
            public void run() {
                for (int i = 10001; i <= 20000; i++) {
                    list.add(i);
                }
            }
        };

        t1.start();
        t2.start();
        t1.join();
        t2.join();

        System.out.println(list.size());
    }
}

5.2、CountDownLatch

CountDownLatch允许一个或多个线程等待其他线程完成操作。

例如：线程1要执行打印：A和C，线程2要执行打印：B，但线程1在打印A后，要线程2打印B之后才能打印C，所以：线程1在打印A后，必须等待线程2打印完B之后才能继续执行。

CountDownLatch构造方法:

public CountDownLatch(int count)// 初始化一个指定计数器的CountDownLatch对象   1

CountDownLatch重要方法:

public void await() throws InterruptedException// 让当前线程等待,当计数器的值为0的时候,就结束等待
public void countDown()	// 计数器进行减1
  • 示例
public class H34 {
    public static void main(String[] args) {
        CountDownLatch latch = new CountDownLatch(1);

        new Thread(){
            @Override
            public void run() {
                System.out.println("开始计算");

                //等待
                try {
                    latch.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println("计算结束");
            }
        }.start();

        new Thread(){
            private int sum = 0;
            @Override
            public void run() {
                for (int i = 1; i < 101; i++) {
                    sum += i;
                }
                System.out.println(Thread.currentThread().getName()+"结果为："+sum);
                latch.countDown();
            }
        }.start();
    }
}

5.3、CyclicBarrier

CyclicBarrier的字面意思是可循环使用（Cyclic）的屏障（Barrier）。它要做的事情是，让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续运行。

例如：公司召集5名员工开会，等5名员工都到了，会议开始。

我们创建5个员工线程，1个开会线程，几乎同时启动，使用CyclicBarrier保证5名员工线程全部执行后，再执行开会线程。

CyclicBarrier构造方法：

public CyclicBarrier(int parties, Runnable barrierAction
    //parties: 代表要达到屏障的线程数量
    //barrierAction:表示达到屏障后要执行的线程

CyclicBarrier重要方法：

public int await()// 每个线程调用await方法告诉CyclicBarrier我已经到达了屏障，然后当前线程被阻塞
  • 示例代码：
/**
*请使用CyclicBarrier编写一个程序。
*	定义第一个线程：计算1--100的所有数的累加和。
*	定义第二个线程：计算1--100的所有偶数的累加和。
*	定义第三个线程：计算1--100的所有奇数的累加和。
*	定义第四个线程：打印：”计算完毕”。
*要求在“第一个线程”、“第二个线程”、“第三个线程”全部执行完毕，再执行“第四个线程”。
*
*/
public class H45 {
    public static void main(String[] args) {

        CyclicBarrier barrier = new CyclicBarrier(3, new Thread() {
            @Override
            public void run() {
                System.out.println("计算完毕！！！！");
            }
        });

        new Thread(){
            private int sum = 0;
            @Override
            public void run() {
                for (int i = 1; i < 101; i++) {
                    sum +=i;
                }
                System.out.println(Thread.currentThread().getName()+"----1-100的和为："+sum);

                try {
                    barrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }
        }.start();

        new Thread(){
            private int sum = 0;
            @Override
            public void run() {
                for (int i = 1; i < 101; i++) {
                    if(i % 2 == 0){
                        sum +=i;
                    }
                }
                System.out.println(Thread.currentThread().getName()+"----1-100的偶数和为："+sum);
                try {
                    barrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }
        }.start();

        new Thread(){
            private int sum = 0;
            @Override
            public void run() {
                for (int i = 1; i < 101; i++) {
                    if(i % 2 != 0){
                        sum +=i;
                    }
                }
                System.out.println(Thread.currentThread().getName()+"----1-100的奇数和为："+sum);
                try {
                    barrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }
        }.start();
    }
}

5.4、Semaphore

Semaphore的主要作用是控制线程的并发数量。

synchronized可以起到"锁"的作用，但某个时间段内，只能有一个线程允许执行。

Semaphore可以设置同时允许几个线程执行。

Semaphore字面意思是信号量的意思，它的作用是控制访问特定资源的线程数目。

Semaphore构造方法：

public Semaphore(int permits)						permits 表示许可线程的数量

Semaphore重要方法：

public void acquire() throws InterruptedException	表示获取许可
public void release()								表示释放许可
  • 示例代码：
/**
* 请使用Semaphore编写一个程序，实现以下效果：有10名游客要参观展览室，而“展览室”同时只允许最多“三个游客”* 参观，每个游客参观时间2秒。
*/
public class H36 {
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(3);
        for (int i = 0; i < 10; i++) {
            new Thread(){
                @Override
                public void run() {
                    try {
                        //获得参观权
                        semaphore.acquire();
                        System.out.println(Thread.currentThread().getName()+"正在参观");
                        //参观时间
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }finally {
                        semaphore.release();
                    }
                }
            }.start();
        }
    }
}

5.5、Exchanger

Exchanger（交换者）是一个用于线程间协作的工具类。Exchanger用于进行线程间的数据交换。

这两个线程通过exchange方法交换数据，如果第一个线程先执行exchange()方法，它会一直等待第二个线程也执行exchange方法，当两个线程都到达同步点时，这两个线程就可以交换数据，将本线程生产出来的数据传递给对方。

A线程 exchange方法 把数据传递B线程

B线程 exchange方法 把数据传递A线程

Exchanger构造方法：

public Exchanger()

Exchanger重要方法：

public V exchange(V x)   参数: 要交换的数据  返回值: 对方线程传递的数据
  • 示例代码：
/**
 * 请使用Exchanger编写一个程序，实现两个线程的信息交互：
 * 	线程A给线程B：一条娱乐新闻
 * 	线程B给线程A：一条体育新闻
 */
public class H37 {
    public static void main(String[] args) {
        Exchanger<String> exchanger = new Exchanger<>();

        new Thread(){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"等待交换");
                String result = null;
                try {
                    result = exchanger.exchange("一条娱乐新闻");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+":"+result);

            }
        }.start();

        new Thread(){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"等待交换");
                String result = null;
                try {
                    result = exchanger.exchange("一条体育新闻");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+":"+result);
            }
        }.start();
    }
}

6、线程池

  • **线程池：**其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。
线程池的好处
  1. 降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
  2. 提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
  3. 提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。
线程池的工作原理:
  • 线程池被创建,就会初始化指定数量的线程
  • 往线程池中添加任务:
    • 如果线程池中有多条空闲的线程,那么就会随机分配线程来执行任务
    • 如果线程池中没有空闲的线程,那么添加的任务就在任务队列中进行等待,当有线程执行完任务,空闲下来了,就会分配空闲线程来执行等待的任务
      在这里插入图片描述
线程池使用

Java里面线程池的顶级接口是java.util.concurrent.Executor，但是严格意义上讲Executor并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是java.util.concurrent.ExecutorService。

要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，很有可能配置的线程池不是较优的，因此在java.util.concurrent.Executors线程工厂类里面提供了一些静态工厂，生成一些常用的线程池。官方建议使用Executors工厂类来创建线程池对象。

Executors类中有个创建线程池的方法如下：

  • public static ExecutorService newFixedThreadPool(int nThreads)：返回线程池对象。(创建的是有界线程池,也就是池中的线程个数可以指定最大数量)

获取到了一个线程池ExecutorService 对象，那么怎么使用呢，在这里定义了一个使用线程池对象的方法如下：

  • public Future<?> submit(Runnable task):获取线程池中的某一个线程对象，并执行任务

  • public <T> Future<T> submit(Callable<T> task):获取线程池中的某一个线程对象，并执行任务

    Future接口：用来记录线程任务执行完毕后产生的结果。

/**
 * 请按以下步骤编写程序：
 * 	定义一个线程类，实现Callable接口。此线程可以计算1--100的所有数字的累加和。
 * 	定义测试类，和main()方法，使用线程池启动线程，并获取计算结果，并将结果打印到控制台。
 */
public class Demo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService pool = Executors.newFixedThreadPool(3);
        MyCallable myCallable = new MyCallable();
        Future<Integer> future = pool.submit(myCallable);
        Integer sum = future.get();
        System.out.println(sum);
    }
}

class MyCallable implements Callable<Integer>{
    private Integer sum = 0;
    
    @Override
    public Integer call() throws Exception {
        for (int i = 1; i <= 100; i++) {
            sum +=i;
        }
        return sum;
    }
}

7、死锁

  • 在多线程程序中,使用了多把锁,造成线程之间相互等待.程序不往下走了；
  • 多条线程,多把锁,造成线程A获取到了线程B需要的锁,而线程B获取到了线程A需要的锁,并且都没有释放
public class H21 {
    public static void main(String[] args) {
        final Object A = new Object();
        final Object B = new Object();

        new Thread(){
            @Override
            public void run() {
                synchronized (A){
                    System.out.println(Thread.currentThread().getName()+"获得A锁");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"尝试获得B锁");
                    synchronized (B){
                        System.out.println(Thread.currentThread().getName()+"获得B锁");
                    }
                }
            }
        }.start();

        new Thread(){
            @Override
            public void run() {
                synchronized (B){
                    System.out.println(Thread.currentThread().getName()+"获得B锁");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"尝试获得A锁");
                    synchronized (A){
                        System.out.println(Thread.currentThread().getName()+"获得A锁");
                    }
                }
            }
        }.start();
    }
}
weixin_43956936
关注
专栏目录
多线程及线程池
Mr.xing的博客
02-15 2836
当多个线程同时访问同一条数据时，不管怎么访问，最终得出的数据结果是正确的，我们就说这个是线程安全的。
【线程状态、volatile关键字、原子性、并发包、死锁、线程池】
WDNMDnm的博客
01-04 224
【线程状态、volatile关键字、原子性、并发包、死锁、线程池】 今日目标 线程安全 volatile关键字 原子性 并发包 死锁 线程池 教学目标 能够说出volatile关键字的作用 实现成员变量多个线程修改后的可见性。 能够说明volatile关键字和synchronized关键字的区别 volatile修饰成员变量，实现变量的访问可见性，但是不能实现原子性。 synchronized可以修饰方法和代码块，加锁机制，可以实现线程安全。加锁以后变量自然可见。 能够理解原子
java(八)-线程安全、volatile关键字、原子性、并发包、死锁、线程池
srmmh的博客
05-23 593
Day08【线程状态、volatile关键字、原子性、并发包、死锁、线程池】 今日目标 线程安全 volatile关键字 原子性 并发包 死锁 线程池 教学目标 能够说出volatile关键字的作用 实现成员变量多个线程修改后的可见性。 能够说明volatile关键字和synchronized关键字的区别 volatile修饰成员变量，实现变量的访问可见性，但是不能实现原子性。 synchronized可以修饰方法和代码块，加锁机制，可以实现线程安全。加锁以后变量自然可见。 能
Java多线程-锁机制（volatile、synchronized、CAS）
九曜
09-07 4812
并发编程的三大特性：可见性、原子性、有序性 volatile保证可见性与部分有序性，但是不保证原子性，保证原子性需要借助synchronized这样的锁机制 volatile（最底层：lock add） ●保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的,volatile关键字会强制将修改的值立即写入主存。 ●禁止进行指令重排序 volatile的可见性 Java内存模型 JMM Java内存模型，是java虚拟机规范中所定义的⼀种内存模型，Java
线程池（详细）& Volatile关键字
温良
07-04 461
声明：我是使用了黑马的资源，因为我感觉黑马基础这里讲的通俗易懂些，且对于画图还是满擅长，便于小白理解。 这里再说下线程的转换状态 线程池出现就是为了解决线程的弊端 代码如下，在两个线程之间插入sleep会只有一条线程是因为第一个线程执行完毕后把线程归还给池子，那么此时线程池就有一条空闲的线程，第二个线程看池子的时候会看有没有空闲的线程，如果有就把第一个线程复用。这里没有sleep会有两条线程是因为第一条线程还来不及归还给池子第二个任务就提交过来了，所以线程池只能自己创建个新的线...
线程安全、volatile关键字、原子性、并发包、死锁、线程池.md
05-31
线程安全、volatile关键字、原子性、并发包、死锁、线程池学习笔记
多线程,线程安全，高并发及线程安全，并发包，线程池方式
shechujiuzhe的博客
09-25 190
多线程,线程安全，高并发及线程安全，并发包，线程池方式，死锁一、多线程1、并发与并行2、线程与进程3、Thread类二、线程安全三、 高并发及线程安全四、并发包五、线程池方式六、死锁二级目录三级目录 一、多线程 1、并发与并行 并行：指两个或多个事件在同一时刻发生（同时执行）。 并发：指两个或多个事件在同一个时间段内发生(交替执行)。 2、线程与进程 进程：进程是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。每个进程都有一个独立的内存空间，一个应用程序
并发编程 (三) 线程安全性之避免线程不安全
小诚信驿站
03-26 347
文章目录一、如何保证线程安全1.1、并发原子类1.2、加锁机制1.3、信号量同步共享数据1.4、封闭线程，不共享数据1.5、发布与逸出二、设计线程安全的类2.1、前提要素2.2、无限制的创建线程有哪些问题三、单例模式问题3.1、引申：单例模式看线程安全3.2、单例模式-懒汉式3.2.1、单线程可以，多线程环境下不安全（加锁）3.2.2、那么如何提高性能？（双重检测机制(DCL)懒汉式）3.2.3、那么如何提高性能？（锁范围缩小导致重排序问题）3.2.4、那么如何提高性能？（volatile 实现可见性）3.
详解Java关键字之 volatile
JavaMonsterr的博客
05-26 695
一、什么是Volatile volatile是Java提供的一种轻量级的同步机制。Java 语言包含两种内在的同步机制：同步块（或方法）和 volatile 变量，相比于synchronized（synchronized通常称为重量级锁），volatile更轻量级，因为它不会引起线程上下文的切换和调度。但是volatile 变量的同步性较差（有时它更简单并且开销更低），而且其使用也更容易出错。 Volatile 可以保证可见性，但不能保证原子性，一种线程同步的机制！很强大来看一道经典面试题~ 请你谈谈
java线程池 synchronized_Java -- 线程池 synchronized 关键字
weixin_42522676的博客
02-26 205
1、基本概念synchronized 关键字提供了一种锁的机制，能够保证共享变量的互斥访问，即同一时刻，只能有一个线程访问同步资源。内存方面，monitor enter 和 monitor exit 两个 JVM 指令，保证了任何线程在 monitor enter 之前必须从主内存中获取数据，在 monitor exit 之后，必须把更新的值刷新到主内存中。这两个 JVM 指令，严格的遵守 hap...
java线程池和volatitle关键字
JSJWR的博客
03-18 498
线程池的目的： （1）假设一个服务器完成一项任务所需的时间是：创建线程的时间T1，线程执行任务的时间T2，线程销毁的时间T3。如果每次请求到达就创建一个新的线程，且并发的线程数量很多，每个线程执行很短时间（T1+T3远大于T2）就结束了，这样频繁创建线程的开销是很大的，同时大大降低系统的效率。 （2）如果在一个JVM里创建太多的线程，可能会使得系统由于过度消耗内存或“切换过度”而导致系统资源不...
Thread线程系列之线程池详解（补充volatile关键字）
LQ的博客
03-28 716
（一）.线程池的详解与使用   @1) 核心:ThreadPoolExecutor类     public ThreadPoolExecutor(int corePoolSize, //核心线程数                              int maximumPoolSize,      //线程允许创建的最大线程数                              ...
线程中的一些关键字
wangzhantao的专栏
03-07 366
      1 线程池（减小线程创建的消耗） 2 synchroinzed：同一对象不同方法锁的互斥 3 reentrantLock(1 tryLock：对象是否已经被锁 2、公平锁的设置) 4 join方法：主线程等待子线程执行完毕 5 volatile：变量在不同线程间可见，通常用在开关变量和计数器变量等等 6 wait、notify、notifyAll：这些方法必须在syn...
线程/线程池/锁知识点介绍
tttalk的博客
01-26 1499
文章目录一、多线程1.多线程实现方式2.线程安全3.JUC开发框架二、Threadlocal1.ThreadLocal介绍2.ThreadLocal实现原理3.ThreadLocal如何避免内存泄漏4.ThreadLocal使用场景三、AQS1.AQS介绍及应用2.AQS实现方式3.如何设计一个互斥的lock4.读写锁ReadWriteLock5.CountDownLactch6.CyclicBarrier四、线程池1.线程池简述2.线程池参数3.线程池实现机制（线程池原理）4.线程池配置方案及调优5.自定
互斥锁，解决原子性问题以及加锁后引发的死锁
湟同学你好的博客
05-01 492
互斥锁，解决原子性问题以及加锁后引发的死锁 原子性的问题就是线程切换。在单核时代，同一时刻只有一个线程工作，禁用CPU中断就能禁止线程切换。多核时代，同一时刻可能有多个线程在执行，禁用CPU中断并不能解决原子性问题。经过上述分析得出结论，同一时刻只有一个线程执行是解决原子性问题的必要条件，这个条件称之为互斥，保证共享变量的修改是互斥的，无论是单核还是多核，都可以保证其原子性。 这里增加多一个概念：...
java线程里关键字与关键方法
你不该把世界让给你所鄙视的人。
07-29 2560
java线程里关键字与关键方法@线程 @sleep @yield @synchronized @wait @join @notify @notifyAll @run @start @volatilejava线程里关键字与关键方法 sleep yield synchronized waitnotifynotifyAll join runstart volatile sleep()-Thread.sle
JAVA多线程的关键字
ZhiguoXue_IT的博客
07-15 891
结合自己的学习，谈java多线程关键字的出现的原因及各种关键字的作用
从线程池到synchronized关键字详解
weixin_34004750的博客
01-20 178
线程池 BlockingQueue synchronized volatile 前段时间看了一篇关于"一名3年工作经验的程序员应该具备的技能"文章，倍受打击。很多熟悉而又陌生的知识让我怀疑自己是一个假的程序员。本章从线程池，阻塞队列，synchronized 和 volatile关键字，wait，notify方法实现线程之间的通讯，死锁，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值