高级Java编程-----JUC基础入门（一）

最新推荐文章于 2024-04-21 23:14:13 发布
最新推荐文章于 2024-04-21 23:14:13 发布
阅读量485 收藏
点赞数 1
分类专栏： java深入基础 文章标签： 多线程 java 并发编程 thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LOL_toulan/article/details/105261560
版权

目录

注：本系列教程只适用于JUC入门

什么是JUC

JUC 就是JavaJDK中的（java.util.concurrent）包的名字的缩写，在jdk1.5开始提供，在此包中增加了在并发编程中很常用的实用工具类，用于定义类似于线程的自定义子系统，包括线程池、异步IO 和轻量级任务框架。提供可调的、灵活的线程池。还提供了设计用于多线程上下文中Collection 实现等。
在这里插入图片描述

回顾初级多线程

我们在学习Java的初级阶段的时候我们，我们一定学过线程，我们回忆一下，创建线程的两大方法

  1. 继承Thread类，重写run方法
  2. 实现Runnable接口

还有一点我们需要注意，重写run方法并不能开启线程，开启线程需要调用Thread.start()方法

我们既然回顾，那就再多写一点，我们来看一道经典的电影院窗口买票的例子

继承Thread类实现

首先：我们来通过继承Thread方法来实现多线程

代码如下：

public class OldThread {
    public static void main(String[] args) {
        Ticket ticket1 = new Ticket("1号窗");
        Ticket ticket2 = new Ticket("2号窗");
        Ticket ticket3 = new Ticket("3号窗");
        ticket1.start();
        ticket2.start();
        ticket3.start();
    }
}
class Ticket extends Thread {


    public Ticket() {
    }

    public Ticket(String name) {
        super(name);
    }

    private static int totalTicket = 100;

    @Override
    public  void run() {
        while (true){
            if (totalTicket > 0) {
                System.out.println(getName() + "卖出第" + (totalTicket--) + "张票，还剩下" + totalTicket + "张票");
            } else {
                break;
            }
        }

    }
}

运行截图：
在这里插入图片描述
问题分析：

我们明显能看出99张票买了2次，这在我们实际生活中是不被允许的，所以我们需要在run方法上加上synchronized，通过加锁来实现同步，让我们的票同一时间只能有一个被线程操作。

public class OldThread {
    public static void main(String[] args) {
        Ticket ticket1 = new Ticket("1号窗");
        Ticket ticket2 = new Ticket("2号窗");
        Ticket ticket3 = new Ticket("3号窗");
        ticket1.start();
        ticket2.start();
        ticket3.start();
    }
}
class Ticket extends Thread {


    public Ticket() {
    }

    public Ticket(String name) {
        super(name);
    }

    private  static int totalTicket = 100;

    @Override
    public synchronized void run() {
        while (true){
            if (totalTicket > 0) {
                System.out.println(getName() + "卖出第" + (totalTicket--) + "张票，还剩下" + totalTicket + "张票");
            } else {
                break;
            }
        }

    }
}

实现Runnable接口

实现Runnable接口来创建开启线程有两种方法，第一，通过在操作类上实现Runnable接口，第二，通过匿名内部类方法实现Runnable接口

public class OldRunnable {
    public static void main(String[] args) {
        Ticket myRunnable = new Ticket();
        new Thread(myRunnable, "1号窗").start();
        new Thread(myRunnable, "2号窗").start();
        new Thread(myRunnable, "3号窗").start();
    }
}


class Ticket implements Runnable {

    private  int totalTicket = 100;

    @Override
    public  void run() {
        while (true){
            if (totalTicket > 0) {
                System.out.println(Thread.currentThread().getName() + "卖出第" + (totalTicket--) + "张票，还剩下" + totalTicket + "张票");
            } else {
                break;
            }
        }
    }
}

匿名内部类实现多线程

public class AnonymousRunnable {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            private int ticket = 30;
            @Override
            public void run() {
                while (true) {
                    if (ticket > 0) {
                        System.out.println(Thread.currentThread().getName() + "卖出第" + (ticket--) + "张票，还剩下" + ticket + "张票");
                    } else {
                        break;
                    }
                }
            }
        },"窗口1").start();
    }
}

多线程的状态

public enum State {
		//创建
        NEW,  
        //就绪，可运行
        RUNNABLE,
		//阻塞 wait，sleep
        BLOCKED,
		//等待，一直等待，（俗称：不见不散）
        WAITING,
        //在一定时间内等待，时间一到，就继续运行（俗称：过期不候）
        TIMED_WAITING,
		//终结
        TERMINATED;
    }
wait和sleep的区别

wait，放开手里的锁阻塞
sleep，不放开锁阻塞

wait和sleep的主要区别是放不放手里的锁

线程的生命周期图

在这里插入图片描述

Lock锁

我们在java.util.concurrent.locks包下我们发现了Lock接口
在这里插入图片描述
我们发现官方文档直接说，Lock实现提供比使用synchronized方法和语句可以获得的更广泛的锁定操作。也就是说Lock的锁机制，比synchronized的更加好。

那他的使用方法是什么呢？

因为我们知道Lock是一个接口，那么我们看看该接口是否有他自己的实现类，实现类如下
在这里插入图片描述
共有三个实现类，但是我们一般使用的是第一个实现类。官方给的使用方法为：

 Lock l = ...;  //我们一般写为 Lock l = new ReentrantLock();
 l.lock(); 
 try {
     // access the resource protected by this lock 
} finally { 
l.unlock(); 
}

所以我们就明白了我们的加锁机制

之前代码：

class Ticket{
    private int number = 30;
    public void saleTicket(){
        if (number > 0) {
            System.out.println(Thread.currentThread().getName() + "正在卖第" + (number--) + "张票，还剩" + number + "张票");
        }
    }
}

/**
 * 多线程编程的口诀：线程  操作   资源类
 */
public class MyLock {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 40; i++) {
                    ticket.saleTicket();
                }
            }
        },"A").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 40; i++) {
                    ticket.saleTicket();
                }
            }
        },"B").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 40; i++) {
                    ticket.saleTicket();
                }
            }
        },"C").start();
    }
}

然后我们就可以将我么们的代码改写

class Ticket{
    private int number = 30;

    private Lock l = new ReentrantLock();

    public void saleTicket(){
        l.lock();
        try {
            if (number > 0) {
                System.out.println(Thread.currentThread().getName() + "正在卖第" + (number--) + "张票，还剩" + number + "张票");
            }
        }finally {
            l.unlock();
        }
    }
}

/**
 * 多线程编程的口诀：线程  操作   资源类
 */
public class MyLock {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 40; i++) {
                    ticket.saleTicket();
                }
            }
        },"A").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 40; i++) {
                    ticket.saleTicket();
                }
            }
        },"B").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 40; i++) {
                    ticket.saleTicket();
                }
            }
        },"C").start();
    }
}

其实匿名内部类我们也可以通过lambda表达式来进行实现

lambda表达式口诀拷贝小括号，写死右箭头，落地大括号

改写后

class Ticket{
    private int number = 30;

    private Lock l = new ReentrantLock();

    public void saleTicket(){
        l.lock();
        try {
            if (number > 0) {
                System.out.println(Thread.currentThread().getName() + "正在卖第" + (number--) + "张票，还剩" + number + "张票");
            }
        }finally {
            l.unlock();
        }
    }
}

/**
 * 多线程编程的口诀：线程  操作   资源类
 */
public class MyLock {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();

        new Thread(() -> { for (int i = 0; i < 40; i++) { ticket.saleTicket(); } },"A").start();

        new Thread(()-> {for (int i = 0; i < 40; i++) {ticket.saleTicket(); }},"B").start();

        new Thread(()->{for (int i = 0; i < 40; i++) {ticket.saleTicket(); }},"C").start();
    }
}

我们发现代码无比简洁，更有条理性，更加容易阅读，提高了观赏性。

Jacobshash
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JUC高并发编程从入门到精通（全）
码农研究僧的博客
08-06 1万+
目录前言 前言 在了解这部分内容的时候 先要了解java的一些基础内容 java零基础从入门到精通（全） javaSE从入门到精通（全） 所谓JUC是java.util .concurrent 工具包的简称这是一个处理线程的工具包可以实现多线程高并发的内容 了解该部分内容先了解线程与进程的相关概念 【操作系统】线程与进程的深入剖析（全） java之Thread类详细分析（全） 以及涉及到的lambda表达式函数的概念 java中lambda表达式 ......
Java高级编程
08-27
Java高级编程、内有Java IO NIO，Java+netty等框架技术详解。
JAVA高级编程
cgmx551的博客
03-02 636
java是一门面向对象的语言 面向对象更注重抽象概念 一处编译 处处运行 —跨平台 操作系统是安装到硬件上的软件 先编译后运行 使用vi 去编辑一个helloworld 然后给他编译运行 编译 javac 源文件名 helloworld.java ----> .class文件 字节码文件 运行java 类名 helloworld jdk java开发工具包 开发人员 jre java运行环境 普通用户 只需要去运行项目 jvmjava虚拟机 进程应用 jdk---->jre 和核心库类—>
Java的高级编程
阿甘正传
05-05 412
Java反射详解，java高级编程api,持续学习，不断更新。
java高级编程
ice_z_tea的博客
10-19 758
1、多线程 概念 在一个时间段上可以同时运行多个程序，对CPU进行资源的轮流抢占。所以在同一个时间段上会有多个程序依次执行，但是在同一个时间点上CPU只会执行一个进程 1.1、多线程编程 Thread实现多线程 Java中的Java.lang.Thread，只要有一个类继承了此类就便是这个类是线程的主体类。但还需覆写Thread类中提供的一个run()方法，而这个方法就是线程的主方法。 但是必须使用Start()方法进行启动 自定义线程类继承Thread类 重写run()方法，编写线程执行体 创建线程对象
JAVA基础知识点-入门必备
f5465245的博客
10-14 4065
本文主要是我之前复习Java基础原理过程中写的Java基础知识点总结。Java的知识点其实非常多，并且有些知识点比较难以理解，有时候我们自以为理解了某些内容，其实可能只是停留在表面上，没有理解其底层实现原理。 纸上得来终觉浅，绝知此事要躬行。笔者之前对每部分的内容对做了比较深入的学习以及代码实现，基本上比较全面地讲述了每一个Java基础知识点，当然可能有些遗漏和错误，欢迎读者指正。 Java基础知识点总结 每部分内容会重点写一些常见知识点，方便复习和记忆，但并不是全部内容。 面向对象三大...
网易云课堂微专业--Java高级开发工程师
xiao99985的博客
06-24 676
获取
java版飞机大战源码-concurrency-practice:并发实践
06-04
《Java并发编程从入门到精通》- 张振华 偏实战 《Java多线程编程核心技术》- 高洪岩 偏实战 《Java并发编程的艺术》- 方腾飞 偏原理 《Java多线程编程实战指南》-核心篇 黄文海 偏实战 《Java并发编程之美》 翟陆续...
JUC高并发编程详细讲解 狂神笔记pdf 从入门到入坟 请与狂神视频配套使用
12-17
JUC，全称为Java Util Concurrent，是Java平台提供的一组用于构建高效并发应用的高级API。这个包包含了各种工具类，帮助开发者处理多线程、同步、线程池、并发容器等问题，以实现更好的性能和资源管理。 在JUC中，...
java web 高级编程
07-03
本人见过最好的国外java web编程书籍，手把手教会小白搭建基于spring框架和hibernate的web应用，并且还着重介绍了websocket，spring security等技术。
JAVA的高级编程
2301_77946570的博客
02-22 763
与泛型类类似，只是方法声明中定义的形参只能在该方法里使用，而接口、类声明中定义的类型形参则 可以在整个接口、类中使用。，即给类型指定一个参数，然后在使用时再指定此参数具体的值，那样这个类型就可以在使用时决定了。当然，这个后面的参数类型也是有规范的，不能像上面一样随意，通常类型参数我们都使用大写的单个。在不指定泛型的情况下，泛型变量的类型为 该方法中的几种类型的同一个父类的最小级，直到。在指定泛型的时候，该方法中的几种类型必须是该泛型实例类型或者其子类。泛型方法，是在调用方法的时候指明泛型的具体类型。
java 高级编程
weixin_33860722的博客
08-31 179
2019独角兽企业重金招聘Python工程师标准>>> ...
java高级编程（暂时完结，持续完善）
weixin_43520128的博客
08-14 1910
Java高级编程一、多线程1 基本概念1.1 程序、进程、线程1.2 单核CPU和多核CPU的理解1.3 并行与并发1.4 使用多线程的优点2、线程的创建和使用2.1 线程的创建和启动2.2 Thread类2.3 API中创建线程的两种方式3、线程的生命周期4、线程的同步5、线程的通信6、JDK5.0新增线程创建方式常用类枚举与注解二级目录三级目录 一、多线程 1 基本概念 1.1 程序、进程、线程 程序：(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一 段静态的代码，静态对象。
Java高级编程学习
weixin_43892090的博客
01-09 1067
目录 类变量/静态变量 Main方法 代码块 类的加载 单例设计模式 Final关键字 抽象类 模板设计模式 1.9日学习笔记 类变量/静态变量 （jdk8以后，静态变量存放在堆里这个类对应的class对象最后，jdk8以前，静态变量存放在方法区） 类变量也叫静态变量/属性，是该类所有对象共享的变量，任何一个该类对象去访问它时，取到的都是相同的值，同样任何一个该类的对象去修改他时，修改的也是同一个变量。 static类变量，在类加载的时候就生成了。（new的时候加载）即使没有创
Java高级编程！一文手把手带你实现自己的数据库连接池！
最新发布
greatming666的博客
04-21 1676
数据库连接池使用了池化的技术，可以复用数据库连接，减少了重复开启连接和关闭连接带来的性能损耗，减轻了数据库的压力，提高了服务器的处理效能。本文将带领读者从零开始使用java从零实现一个数据库连接池。
java高级编程之深入
网站开发初中级代码参考-转载
09-18 183
首先从基础开始， 静态方法的导入： 包名.类名.静态属性|静态方法|； 这种方法比较简单，有利于减少代码，但是必须记住每个包里的类的方法和属性；这是前提，如果不能记清的话，也只能按以前的方法来，也没有太大的区别； 举例： importjava.lang.System,out;//写完之后，底下的输出就可以直接用out可以了； pubicstaticvoidmian(Stringargs...
Java并发编程入门：理解JUC与多线程模型
JUC是Java提供的一套高级并发框架，它包含了诸如`Executor`, `Future`, `Semaphore`, `CountDownLatch`, `CyclicBarrier`, `ConcurrentHashMap`等实用工具，用于简化并发编程的复杂性。 在文章中，首先提到了线程和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值