JUC编程的学习（一）

最新推荐文章于 2024-10-30 18:07:32 发布
最新推荐文章于 2024-10-30 18:07:32 发布
阅读量193 收藏
点赞数 1
分类专栏： 多线程 文章标签： java 多线程 并发编程 thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39126213/article/details/104947772
版权

JUC编程的学习（一）

JUC的学习（一）

1.线程和进程(回顾)

线程和进程概括：

进程：

1.一个运行的程序，qq.exe,程序的集合；

2.一个进程往往可以包含多个线程，至少一个！

3.java默认有几个？ 2个 main线程 GC线程

线程：

开了一个进程比如Typora，写字，自动保存都是一个线程
对于java而言：Thread，Runnable，Callable

问题来了：java真的可以开启一个线程吗？ 答案是： 开不了！java无法开启硬件，start方法里面调用了start0方法是一个本地方法。

并发编程：并发、并行

并发（多线程操作同一个资源）：

  • 单核CPU快速交替运行，造成并发的假象

并行（多个人一起走）：

  • CPU多核，多个线程可以同时执行
public class demo01 {
    public static void main(String[] args) {
        //获取cpu的核数
        //cpu密集型 ，IO密集型 
        System.out.println(Runtime.getRuntime().availableProcessors());
    }
}

并发编程的本质：充分利用CPU的资源 （企业看重）

线程有几个状态？

public enum State {
    //新生
    NEW,
	//运行
    RUNNABLE,

	//阻塞
    BLOCKED,

   //等待，死死的等
    WAITING,
	
  	//超时等待
    TIMED_WAITING,

	//终止
    TERMINATED;
}

wait和sleep的区别

1.来自不同的类

wait => Object (一般不使用)

sleep=>Thread

企业中会使用JUC包下的TimeUnit来操作

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

2.关于锁的释放

wait会释放锁，而sleep会抱着锁不放。

3.使用的范围不同

wait：必须在同步代码块中，不需要捕获异常

sleep：可以在任何地方睡，需要捕获异常

2.Lock锁

1.先回顾synchronized

我们用卖票的demo来尝试

//卖票，摒弃传统的实现Runnable接口的卖票，解耦，直接在线程里面操作资源
public class SaleTicket {

    public static void main(String[] args) {

        Ticket ticket = new Ticket();
        //@FunctionalInterface 函数式接口
        new Thread(()->{
            for (int i=1;i<40;i++){
                ticket.sale();
            }
        },"黄牛A").start();

        new Thread(()->{
            for (int i=1;i<40;i++){
                ticket.sale();
            }
        },"黄牛B").start();

        new Thread(()->{
            for (int i=1;i<40;i++){
                ticket.sale();
            }
        },"黄牛C").start();

    }

}

//资源类 OOP
class Ticket{
    private int number = 30;

    public synchronized void sale(){
        if (number>0){
            System.out.println(Thread.currentThread().getName()+"卖出了第"+(number--)+"张票，还剩余："+number);
        }
    }

    //锁对象
    //class

在这里插入图片描述

2.使用Lock来实现卖票

这是Lock的实现类。
在这里插入图片描述

可重入锁是最一般我们最常用的锁，可以由参数指定自己的可重入锁锁，是公平锁还是非公平锁。

在这里插入图片描述

public class SaleTicketdemo02 {
    public static void main(String[] args) {


        Ticket2 ticket2 = new Ticket2();
        new Thread(()->{for (int i=1;i<=10;i++) ticket2.sale();},"黄牛A").start();
        new Thread(()->{for (int i=1;i<=10;i++) ticket2.sale();},"黄牛B").start();
        new Thread(()->{for (int i=1;i<=10;i++) ticket2.sale();},"黄牛C").start();
    }
}

// Lock三部曲
//1.Lock lock = new ReentrantLock();
//2.lock.lock();  //上锁
//3.释放锁  lock.unlock();
class Ticket2 {
    private int number = 30;

    Lock lock = new ReentrantLock();


    public void sale() {

        lock.lock();

        try {
            if (number > 0) {
                System.out.println(Thread.currentThread().getName() + "卖出了第" + (number--) + "张票，还剩余：" + number);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //释放锁
            lock.unlock();
        }
    }

}

3.Synchronized和Lock的区别（重要）

1. Synchronized是java中的关键字，而Lock是类
2. Synchronized无法获取锁的状态，而Lock可以判断是否获取到了锁
3. Synchronized会自动释放锁，而Lock需要手动去释放（unlock）
4. Synchronized 线程1（获取了锁），线程2（就一直傻等）；Lock锁就不一定会一直等下去
5. Synchronized可重入锁，不可以中断，非公平；Lock，可重入锁，可以判断锁，非公平锁（可以自己设置）
6. Synchronized 适合锁少量代码同步问题，Lock适合锁大量的同步代码
7. Lock只有代码块锁，而Synchronized还有方法锁

3.生产者和消费者问题

1.传统方式

package com.xy.pc;

/**
 * @author xiaye
 * @create 2020-03-18-14:56
 */

import javax.xml.crypto.Data;
import java.util.Date;

/**
 * Synchronized 版本的生产者消费者
 * 线程之间的通信问题：生产者和消费者问题！  等待唤醒，通知唤醒
 * 线程交替执行  A   B 操作同一个变量   num = 0
 * A num+1
 * B num-1
 */
public class productConsume01 {
    public static void main(String[] args) {
        Num num = new Num();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    num.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "A").start();


        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    num.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "B").start();


        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    num.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "c").start();



        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    num.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "d").start();


    }
}

//数据类
class Num {
    private int num = 0;

    //  +1
    public synchronized void increment() throws InterruptedException {

        while (num != 0) {
            //如果数字不为0，等待
            wait();
        }
        num++;
        System.out.println(Thread.currentThread().getName() + "===>" + num);
        //通知其他线程我执行完了 +1
        this.notifyAll();
    }


    //  -1
    public synchronized void decrement() throws InterruptedException {
        while (num == 0) {
            //如果数字等于，就等待
            wait();
        }
        num--;
        System.out.println(Thread.currentThread().getName() + "===>" + num);
        //通知其他线程我执行完了 -1
        this.notifyAll();

    }

}

2.JUC 版

package com.xy.pc;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author xiaye
 * @create 2020-03-18-15:25
 *
 * JUC版本的生产者和消费者
 * 使用Lock和COndition来代替syhchronized 和wait ，notifyAll
 */

public class productConsumeLock {
    public static void main(String[] args) {
        Num2 num = new Num2();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    num.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "A").start();


        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    num.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "B").start();


        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    num.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "C").start();


        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    num.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "D").start();


    }
}

//数据类
class Num2 {
    private int num = 0;
    private Lock lock = new ReentrantLock();
    private Condition  condition = lock.newCondition();

    //  +1
    public  void increment() throws InterruptedException {

        //上锁
        lock.lock();

        try {

            while(num!=0){
                //等待
                condition.await();
            }
            num++;
            System.out.println(Thread.currentThread().getName()+"===>"+num);
            //通知所有人已经+1
            condition.signalAll();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //解锁
            lock.unlock();
        }

    }


    //  -1
    public  void decrement() throws InterruptedException {

        lock.lock();
        try {
            while (num == 0) {
                //如果数字等于，就等待
                condition.await();
            }
            num--;
            System.out.println(Thread.currentThread().getName() + "===>" + num);
            //通知其他线程我执行完了 -1
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }


    }

}

3.指定唤醒线程，多个监视器

package com.xy.pc;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author xiaye
 * @create 2020-03-18-16:08
 * <p>
 * <p>
 * A 执行完调用B，B执行完调用C，C执行完调用A
 */

public class productConsumeLock02 {

    public static void main(String[] args) {
        Num3 num = new Num3();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    num.oprationA();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "A").start();


        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    num.oprationB();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "B").start();


        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    num.oprationC();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "C").start();





    }
}

//数据类
class Num3 {
    private int num = 1;
    private Lock lock = new ReentrantLock();
    private Condition conditionA = lock.newCondition();
    private Condition conditionB = lock.newCondition();
    private Condition conditionC = lock.newCondition();

    //  1 A操作  2 B操作  3 C操作
    public void oprationA() throws InterruptedException {

        //上锁
        lock.lock();

        try {

            while (num != 1) {
                //等待
                conditionA.await();
            }
            num = 2;
            System.out.println(Thread.currentThread().getName() + "===>已经操作完成，该B了");
            //通知B,操作啦
            conditionB.signal();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //解锁
            lock.unlock();
        }

    }


    public void oprationB() throws InterruptedException {

        lock.lock();

        try {

            while (num != 2) {
                //等待
                conditionB.await();
            }
            num = 3;
            System.out.println(Thread.currentThread().getName() + "===>已经操作完成，该C了");
            //通知C,操作啦
            conditionC.signal();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //解锁
            lock.unlock();
        }


    }

    public void oprationC() throws InterruptedException {

        lock.lock();

        try {

            while (num != 3) {
                //等待
                conditionC.await();
            }
            num = 1;
            System.out.println(Thread.currentThread().getName() + "===>已经操作完成，该C了");
            //通知A,操作啦
            conditionA.signal();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //解锁
            lock.unlock();
        }


    }


}
code_night
关注
专栏目录
JUC编程学习笔记
aimerary的博客
05-31 305
JUC编程学习笔记什么是JUC线程和进程java能开启线程吗并发和并行线程的状态wait和sleepLock锁TestJUC01（synchronized锁）TestJUC02（Lock锁）synchronized和Lock的区别TestJUC03（生产者消费者问题synchronized版）Condition类TestJUC04（生产者消费者问题Lock锁）TestJUC05（Condition监视器实现精准唤醒，且不需要标识符）8锁（锁的8个问题）问题1、2：正常情况下，两个线程谁先执行？A线程执行时睡
面试官：如何终止线程？有几种方式？
Mr_wxc的博客
04-23 8454
在 Java 中有以下 3 种方法可以终止正在运行的线程： 使用退出标志，使线程正常退出，也就是当 run() 方法完成后线程终止； 使用 stop() 方法强行终止线程，但是不推荐使用这个方法，因为使用此方法不安全，目前该方法已被弃用； 使用 interrupt()方法中断线程。 第一种：使用标志位终止线程 使用标志位终止线程就是定义一个boolean型的标志位 ，在线程的run方法中根据这...
JUC并发编程学习知识点整理
mohanhan13131的博客
12-18 631
一、JUC并发编程 面试高频问！ jdk帮助文档: http://docs.oracle.com/javase/8/docs/api/ [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1Tj3sTCz-1639826957348)(F:\人生苦短，我用JUC\笔记区域\JUC并发编程.assets\image-20211216194401961.png)] 业务：普通的线程代码： Thread Runnable: 没有返回值，效率相比Callable相对较低 1.1 回顾以前
JUC编程归纳
weixin_40695328的博客
02-10 206
主要关注concurrent atomic locks function包 并发和并行是不一样的 并发主要目的是为了充分地利用单核CPU的资源 而并行是在多核CPU下的概念 java线程状态 ：new runnable blocked waiting（等待） time_waiting(延迟等待) terminated waiting：不占有锁 不占有cpu资源 sleep：占有锁 不占有cpu...
JUC并发编程常见面试题目
corlor_龙的博客
04-26 1914
1. 进程和线程，并发和并行 进程：进程是计算机程序在一个数据集上的一次运行过程，也是资源分配和调度的基本单位 线程：线城是进程中的一个执行单元。一个进程中至少有一个线程 并行：指的是两个或多个事件在同一时刻发生， 并发：指的是两个或多个事件在同一时间间隔内发生 2. 守护线程和用户线程的区别 用户 (User) 线程：运行在前台，执行具体的任务，如程序的主线程 守护 (Daemon) 线程：运行在后台，为用户线程服务。一旦所有用户线程都结束运行，守护线程会随 JVM 一起结束工作，如垃圾回收线
JUC并发编程
热门推荐
识时务者的个人博客
07-08 14万+
JUC并发编程 JUC简介 进程、线程的关系 Java默认有两个线程 线程的六种状态 并发、并行的关系： Lock锁 Synchronized 和 Lock的区别 8锁现象 问题一 : 在标准情况下，两个线程先打印 发短信 还是 打电话 ？ 问题二 : 在发短信方法中，延迟4秒，两个线程先打印 发短信 还是 打电话？ 问题三 : Phone类增加一个普通方法，线程B调用，那么两个线程先打印 发短信
JUC并发编程学习笔记(硅谷)
07-23
"JUC并发编程学习笔记(硅谷)"很可能包含了关于Java并发工具集（Java Util Concurrency, JUC）的深入理解和实战经验。JUC是Java标准库提供的一套强大的并发处理工具，它极大地简化了多线程编程，提高了程序的可读性...
JUC并发编程与源码分析视频课.zip
12-16
JUC是Java平台提供的一组高级并发工具包，它极大地简化了多线程编程，并提供了更高效、安全的并发解决方案。在本课程中，你将学习到如何利用这些工具来提升应用程序的并发性能，同时理解其底层实现原理。 课程内容...
JUC并发编程.rar
12-14
总之，"JUC并发编程.rar"是一个宝贵的资源，它涵盖了Java并发编程的关键方面，无论你是想提升你的并发编程技能，还是在面临并发问题时寻找解决方案，这个资料都将大有裨益。通过深入学习和实践，你将能够更好地理解...
艾编程coding老师：JUC 并发编程 + 底层原理.pdf
03-26
JUC（java.util.concurrent）是Java提供的一个并发编程工具包，它是为了更高效地处理线程同步和线程间协作而设计的一系列类和接口。JUC从JDK 1.5版本开始被引入，并随着后续版本的更新不断丰富和完善。JUC的出现极大...
JUC高并发编程从入门到精通（全）
码农研究僧的博客
08-06 1万+
目录前言 前言 在了解这部分内容的时候 先要了解java的一些基础内容 java零基础从入门到精通（全） javaSE从入门到精通（全） 所谓JUC是java.util .concurrent 工具包的简称这是一个处理线程的工具包可以实现多线程高并发的内容 了解该部分内容先了解线程与进程的相关概念 【操作系统】线程与进程的深入剖析（全） java之Thread类详细分析（全） 以及涉及到的lambda表达式函数的概念 java中lambda表达式 ......
JUC编程入门(高并发)
萌新Java工程师
11-17 794
JUC编程 与JUC编程相关的包 一.线程和进程 一个进程往往包含多个线程，至少包含一个线程 java默认有几个线程？ mian线程和GC线程（垃圾回收） 对于java而言：Thread、Runnable、Callable 一般是他们来开启进程 java真的能开启线程么？ java是不能开启线程的 public synchronized void start() { /** * This method is not invoked for the main method thread o
JUC学习 二
Owen_L_Y的博客
12-03 270
一、闭锁：java.util.concurrent.CountDownLatch 1、CountDownLatch是一个同步辅助类，在完成一组正在其他线程执行的操作之前，可以使一个、或多个线程处于等待状态。 2、闭锁可以延缓线程的进度直至到达终点状态，可以确保某些活动在其他活动完成后才执行： 确保某个计算在它所需要的资源都初始化后才继续执行； 确保某个服务在其依赖的其他服务都启动后才启动； 等待直...
JUC | 面试题整理
俺老孙来也
02-17 1万+
寒假对java 并发编程所做的一些理解笔记 双击图片放大 word文档需要的话，请发评论！
服务器虚拟化
最新发布
Hellc007的博客
10-30 368
服务器虚拟化是一种将物理服务器的计算资源分割为多个独立虚拟环境的技术，通过软件层将底层硬件资源抽象化并在上层构建多个虚拟机（Virtual Machine, VM）。每个虚拟机运行独立的操作系统和应用程序，相互之间不受干扰，具备类似于物理服务器的功能。这种技术使得一台物理服务器能够承担多台虚拟服务器的角色，从而极大地提升了硬件资源的利用率。服务器虚拟化的概念最早可追溯到20世纪60年代IBM大型机时代，当时虚拟化被用来将大型机的资源分配给多个任务，使得企业在有限的资源下能够同时运行多个应用。
（1）Java 编程基础概览：数据类型、常量、变量、标识符与运算符
码界领航的Cherry Yang的博客
10-28 934
8 位，占1个字节，有符号的，范围 -128（-2^7）至 127（2^7-1）。32 位，占4个字节，范围 -2,147,483,648（-2^31）至 2,147,483,647（2^31 - 1）。Java 提供了六种数字类型，其中四个为整数类型，两个为浮点类型，还有字符类型，以及布尔型。16 位，占2个字节，范围 -32768（-2^15）至 32767（2^15 - 1）64 位，占8个字节，范围 -2^63 至 2^63 - 1。16 位 Unicode 字符，占 2 个字节。
java_方法递归调用
HHppGo的博客
10-27 428
简单的说: 递归就是方法自己调用自己,每次调用时传入不同的变量.递归有助于编程者解决复杂问题,同时可以让代码变得简洁。
Java Web开发教程：从入门到精通
孤客科技
10-25 1082
Java Web开发是一个充满挑战和机遇的领域。通过本文的学习，您应已掌握Java Web开发的基础知识和实践技巧。不断实践、深入学习，将使您在这个领域越走越远。希望您能在未来的开发旅程中创造出更多精彩的Web应用！如有任何问题或想法，欢迎在评论区留言讨论！期待您的参与与分享！
Java复习24（PTA)
2301_79272475的博客
10-30 225
Java复习24（PTA)：多种排序的book类*
Java JUC并发编程高级教程
Java JUC（java.util.concurrent）是Java 5.0及以后版本引入的一个重要包，专门用于提升并发编程的效率和可管理性。这个包包含了一系列工具类和接口，旨在简化多线程编程，提高程序的并发性能，并减少线程同步的复杂...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值