Java多线程基础

已于 2022-04-11 22:19:58 修改
阅读量3.4k 收藏
点赞数
分类专栏： Java 文章标签： java
于 2022-03-01 19:45:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zdreamLife/article/details/123191467
版权

#博学谷IT学习技术支持#

0.什么是多线程？

1.那什么是并发？什么是并行呢？

2.什么是进程？什么是线程？

3.Java中实现多线程有三种实现方式。三种！三种！三种！

3.1 继承Thread类

3.2第二种是实现Runnable接口

3.3 Callable

3.4 线程的一些属性

4.经典窗口售票问题

4.1 正确示例  --Runnable 实现

4.2 错误示例 --Thread实现

4.3 同步方法实现

4.4 lock锁实现--ReentrantLock

5.写个死锁(面试题)

6.老八吃汉堡(线程等待和线程唤醒机制)

7.阻塞队列

8.线程的状态(6种)

0.什么是多线程？

比如你边打游戏边和女朋友电话，你的大脑cpu 就是开了两个线程，最后会怎么样，大脑过载，游戏输了，女朋友跑了。

1.那什么是并发？什么是并行呢？

并发：你边打游戏，边和你女朋友打电话，这个行为呢就是并发，因为只有一个大脑，这两件事肯定是交替进行的，所以你女朋友会生气。

并行：你打游戏，我来陪你女朋友打电话，那么我和你的行为就是并行，因为有两个大脑，这两件事不会冲突。

2.什么是进程？什么是线程？

你开个游戏呢就是一个进程，在游戏里走位，放技能，就是不同的线程

3.Java中实现多线程有三种实现方式。三种！三种！三种！

3.1 继承Thread类

线程开启是  start()  方法 重写的方法类是 run()

public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName()+"我是一个大帅哥！");
        }
    }
    public static void main(String[] args) {
        //继承了线程类之后呢，该类呢也就变为一个线程类，你每new一个对象那么就是一个线程
        MyThread thread = new MyThread();
        MyThread thread1 = new MyThread();
        //线程启动，启动了不能重复启动，除非该线程停止之后
        thread.start();
        thread1.start();

        //thread.run()和thread.start()的区别就是线程名字不一样。 
        //Thread.currentThread().getName()
    }
}

3.2第二种是实现Runnable接口

public class MyRunable implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"我是一个无敌大帅哥！");
    }

    public static void main(String[] args) {
        MyRunable myRunable = new MyRunable();
        //这边需要说明的是Thread自己本身也实现了Runnable接口
        Thread mythread = new Thread(myRunable);
        mythread.start();
    }
}

3.3 Callable<Object>

//Callable<String>这边的String是返回值的类型
public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        for (int i = 0; i <10 ; i++) {
            System.out.println("我疯狂的E");
        }
        return "面对疾风吧!";
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //任务的容器
        MyCallable myCallable = new MyCallable();
        //接收返回值的容器
        FutureTask<String> futureTask = new FutureTask<>(myCallable);
        //线程
        Thread thread = new Thread(futureTask);
        thread.start();
        System.out.println(futureTask.get());
    }
}

3.4 线程的一些属性

Thread thread1 = new Thread(futureTask1);
        thread1.setName("yasuo");
//线程的优先级越高，那么先执行的概率越高，并不是百分之百抢占
        thread1.setPriority(3);
//线程有两种调度，分时调度和抢占调度。java里面是抢占调度
//设置成守护进程，如果别的线程执行完了，那么这个线程也就结束
        thread1.setDaemon(true);

4.经典窗口售票问题

4.1 正确示例  --Runnable 实现

public class Ticket12307 implements Runnable{
    private int num = 100;
    private Integer a = 0;
    @Override
    public void run() {

        //这边的循环就是当作一个不停的程序
        while(true){
            //这边必须是对象 int 不行
            //这边需要注意的是代码块这这边的a必须是同一个对象，我多个线程不能个拿各的a，可以看下面调用
            //实际上操作的是一个对象，这个a可以没有实际的意义，可以理解为谁抢到了a的使用权，就可以执行下面的
            //代码块的代码。
            //思考一下这边a改成this行不行？
            synchronized (a){
                if(num>0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    num--;

                    System.out.println(Thread.currentThread().getName()+"还剩"+num);

                }else{
                    System.out.println("没票了！");
                    break;
                }
            }
        }

    }

    public static void main(String[] args) {
        //这边操作的是一个对象
        //用三个线程去调用了
        //下面我会举一个不同的例子就是自己用自己的锁
        //需要注意的是这便是用Runnable实现的下面用Thread来实现
        Ticket12307 ticket12307 = new Ticket12307();
        Thread one = new Thread(ticket12307);
        Thread two = new Thread(ticket12307);
        Thread three = new Thread(ticket12307);
        one.setName("窗口1");
        two.setName("窗口2");
        three.setName("窗口3");
        one.start();
        two.start();
        three.start();

    }
}

4.2 错误示例 --Thread实现

public class Ticket12308 extends Thread{
    //这边关注一下，为什么加static 因为多线程关系，会创建多个类；
    //如果不创建static 那么num就会有多个，操作的不是同一个对象就没有意义了
    private static int num = 100;

    private static Integer b = 100;
    @Override
    public void run() {
        while(true){
            //这边的this 指的就是Ticket12308这个对象，new多个很显然不是一个对象
            //这边修改的话必须使用同一个对象
            //synchronized (b) 这个是正确的
            synchronized (this){//这个是错误的。思考一下synchronized (Ticket12308.class)行不行
                if(num>0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    num--;

                    System.out.println(Thread.currentThread().getName()+"还剩"+num);

                }else{
                    System.out.println("没票了！");
                    break;
                }
            }
        }
    }

    public static void main(String[] args) {
        //注意这边是new了两个对象那么关注一下上面同步代码块里的this，你觉得两个线程是同一个this吗？
        Ticket12308 ticket12308 = new Ticket12308();
        Ticket12308 ticket12308Two = new Ticket12308();
        ticket12308.start();
        ticket12308Two.start();
    }
}

4.3 同步方法实现

public class Ticket12309 implements Runnable{

    private static int num = 100;

    @Override
    public void run() {
        while(true){
            if(SellTickets()){
                break;
            }
        }
    }
    //这边是用同步代码块，这个也相当于synchronized(this),是在Runnable中实现是可以的，Thread是不行的
    private synchronized boolean SellTickets(){
        if(num>0){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            num--;

            System.out.println(Thread.currentThread().getName()+"还剩"+num);
            return false;
        }else{
            System.out.println("没票了！");
            return true;
        }
    }

    public static void main(String[] args) {
        Ticket12309 ticket12309 = new Ticket12309();
        Thread one = new Thread(ticket12309);
        Thread two = new Thread(ticket12309);
        Thread three = new Thread(ticket12309);
        one.setName("窗口1");
        two.setName("窗口2");
        three.setName("窗口3");
        one.start();
        two.start();
        three.start();

    }
}

4.4 lock锁实现--ReentrantLock

import java.util.concurrent.locks.ReentrantLock;

public class Ticket12305 implements Runnable{
    private int num = 100;
    private ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {

        while(true){
            //开启锁
            lock.lock();
            try {
                if(num>0){
                    Thread.sleep(100);
                    num--;
                    System.out.println(Thread.currentThread().getName()+"还剩"+num);

                }else{
                    System.out.println("没票了！");
                    break;
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                //释放锁
                lock.unlock();
            }
        }

    }

    public static void main(String[] args) {
        Ticket12305 ticket12305 = new Ticket12305();
        Thread one = new Thread(ticket12305);
        Thread two = new Thread(ticket12305);
        Thread three = new Thread(ticket12305);
        one.setName("窗口1");
        two.setName("窗口2");
        three.setName("窗口3");
        one.start();
        two.start();
        three.start();

    }
}

5.写个死锁(面试题)


//锁嵌套产生的死锁
public class MyDeadLock {
    public static void main(String[] args) {
        Integer a = 10;
        Integer b = 20;
        new Thread(()->{
            //这边的while 模拟一直有请求
            while(true){
                synchronized (a){
                    synchronized (b){
                        System.out.println("我出来了！！！！问僧特");
                    }
                }
            }
        }).start();

        new Thread(()->{
            //这边的while 模拟一直有请求
            while (true){
                synchronized (b){
                    synchronized (a){
                        System.out.println("我出来了！！！！德莱文");
                    }
                }
            }
        }).start();
    }
}

6.老八吃汉堡(线程等待和线程唤醒机制)

重要的不是代码本身，重要的是想一下不加锁，会产生什么情况

这边只有两个线程，唤醒就是唤醒对方

public class OldEightEatHanBaoBao {
    //做八个，吃八个
    static int num = 8;
    //做一个吃一个，hava 表示现在做好了没
    static boolean have = false;
    static Integer lock = 0;
    public static void main(String[] args) {
        //老八做汉堡的线程
        new Thread(()->{
            //这边一直做，做够8个汉堡就结束
            while(true){
                synchronized (lock){
                    if(num==0){
                        //做完了
                        System.out.println("全部做完了");
                        break;
                    }else{
                        if(!have){
                            have =true;
                            System.out.println("老八蜜汁小汉堡！"+num);
                            num--;
                            //这边唤醒所有在这把锁等待的线程
                            //lock.notifyAll();
                            lock.notify();
                        }else{
                            try {
                                //这边的线程等待状态必须用当前锁对象才可以进行等待
                                lock.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
            }
        }).start();
        //老八吃汉堡
        new Thread(()->{
            //这边一直吃，全部吃完就停止
            while(true){
                synchronized (lock){
                    if(have){
                        System.out.println("吃完了害嗨害！");
                        have =false;
                        //lock.notifyAll();
                        lock.notify();
                    }else{
                        if(num==0){
                            System.out.println("全部吃完了");
                            break;
                        }else{
                            try {
                                lock.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }

                    }
                }
            }
        }).start();

    }
}

7.阻塞队列

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class Quene {
    public static void main(String[] args) throws InterruptedException {
        //这边阻塞队列就是用锁做的，取不到就会一直等待
        ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<String>(5);
        //LinkedBlockingQueue queueOne = new LinkedBlockingQueue();
        queue.put("1");
        System.out.println(queue.take());
        queue.take();//如果去不到就会等待。
    }
}

8.线程的状态(6种)

线程状态标识线程状态出现时间点
NEW新建状态new Threa() 还没有start的时候
RUNNABLE就绪状态start() 之后cpu调度到了就是运行态，没调度到就是就绪态
BLOCKED阻塞状态遇到了锁，有其他线程先拿到了锁，等锁释放的过程就是阻塞状态
WAITING等待状态wait() 方法调用之后的状态
TIMED_WAITING有时间的等待状态sleep()
TERMINATED死亡状态线程内定义的方法也就是run()里的方法执行完成之后
你给我翻译翻译什么叫牛牛牛的代码
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java多线程基础知识
01-25
Java多线程基础知识 Java多线程基础知识是Java编程语言中的一项重要技术，用于提高程序的执行效率和响应速度。在这里，我们将详细介绍Java多线程基础知识的相关概念和技术。 一、程序、进程和线程 程序（Program...
JAVA多线程基础
10-09
学习此资源的内容，会让读者对JAVA多线程有一个比较清晰的理解，以至于为今后更深入的学习打下良好的基础
Mybatis识别Integer 0为空字符串问题
u014730338的专栏
07-23 2244
项目中的实体用到大量的状态位，一般都是用Integer 来标识，在项目中遇到一个问题，就是传入的状态值为0，但是拼接的SQL却没有拼接进去。 起初看了mybatis的源码，以为是转BigDecimal的时候，将空字符串和0都识别成了0，转念一想不对，都识别成0也要能够判断不是空，而且敲了一下代码实验一下，new BigDecimal("");会抛出 throw new NumberForma...
Java多线程基础知识
gldzzznb的博客
04-10 3315
这是我再次学习多线程知识的一个总结，对于刚刚接触的学习者是比较友好易懂的，便于快速的理解和掌握。
Java多线程基础（一）
计蒙不吃鱼的博客
07-19 5828
文章分两份，第一份主要内容为1-4点 1.多线程的概念 2.Java程序运行原理 3.实现多线程的2种方式 4.2种方式的区别 5.线程同步（同步锁） 6.同步线程之间的通讯 1.多线程的概念 （1）并发和并行 并行：多个CPU实例或是多台机器同时执行一段处理逻辑，是真正的同时。 并发：通过CUP调度算法，让用户看上去同时去执行，实际上从CPU操作层面并不是真正的同时。并发往往需要公共的资源，...
Java多线程（超详细！）
一只小菜鸡
05-13 12万+
1、什么是进程？什么是线程？ 进程是:一个应用程序（1个进程是一个软件）。 线程是：一个进程中的执行场景/执行单元。 注意：一个进程可以启动多个线程。 eg.对于java程序来说，当在DOS命令窗口中输入： java HelloWorld 回车之后。 会先启动JVM，而JVM就是一个进程。 JVM再启动一个主线程调用main方法。 同时再启动一个垃圾回收线程负责看护，回收垃圾。 最起码，现在的java程序中至少有两个线程并发， 一个是垃圾回收线程，一个是执行main方法的主线程。 3、进程和线程是什么关系？
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
热门推荐
qq_35716689的博客
03-10 14万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
Java 多线程基础概念
明月燃雨
09-19 1万+
什么是进程？ 进程是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。操作系统在运行一个程序时，会为其创建一个进程。 什么是线程？ 线程与进程类似，但线程是一个比进程更小的执行单元，一个进程在执行过程中可以产生多个线程，线程是操作系统调度的最小单元。 在 Java 中，同一进程的多个线程共享该进程的堆和方法区资源，但每个线程都有自己独立的程序计数器、虚拟机栈和本地方法栈，所以系统在线程之间切换工作的负担要比进程小，因此线程也被叫做轻量级进程。 Java
java多线程基础五——isAlive()方法解释
Xmumu_的博客
02-15 3717
方法简单解释 该方法的功能就是判断当前的线程是否处于活动状态，那么什么是活动状态呢，活动状态就是线程已经启动且尚未终止，当线程正在运行或着准备开始运行的时候，就认为线程是“存活”的，并且以true和false的形式返回，下面举个小栗子： package MyThread; public class mythread extends Thread{ @Override public void run() { System.out.println("run="+this.isAlive());
Java 多线程编程基础(详细)
一夜星尘
11-03 3万+
Java多线程编程基础进程与线程多线程实现Thread类实现多线程Runnable接口实现多线程Callable接口实现多线程多线程运行状态多线程常用操作方法线程的命名和获取线程休眠线程中断线程强制执行线程让步线程优先级设定线程的同步和锁死线程同步处理线程死锁 进程与线程 进程与线程的基本认识 进程（Process）：进程是程序的一次动态执行过程，它经历了从代码加载、执行、到执行完毕的一个完整过程；同时也是并发执行的程序在执行过程中分配和管理资源的基本单位，竞争计算机系统资源的基本单位。 线程（Thread
Educoder头歌—Java多线程基础常用函数
赵士杰——成功并非一蹴而就，而是在持之以恒的努力中逐渐实现。
03-23 7141
文章目录第1关：线程的状态与调度任务描述相关知识线程的状态与调度线程优先级编程要求题第2关：常用函数（一）任务描述相关知识2sleep()函数join()函数编程要求测试说明代码示例第3关：常用函数（二）任务描述相关知识yield 函数wait 函数线程常用函数总结编程要求测试说明代码示例 第1关：线程的状态与调度 任务描述 本关任务：学习本关知识完成选择题。 相关知识 为了完成本关你需要掌握： 1.线程的状态与调度； 2.线程执行的优先级。 线程的状态与调度 如果看懂下图，你对线程的了解就会更上一层楼。
Java多线程干货系列（1）Java多线程基础编程开发技术
11-22
Java多线程是Java编程中的重要...以上内容仅涵盖了Java多线程基础编程的一部分知识点，实际开发中还需要关注更多的并发控制策略、性能优化和调试技巧。对于深入理解Java多线程，还需要学习和实践更多相关的高级特性。
Java多线程基础-01、数组概述.rar
11-20
本资料“Java多线程基础-01、数组概述”将带你入门Java的多线程世界，并结合数组这一基本数据结构进行讲解。 首先，我们需要理解什么是线程。线程是操作系统分配CPU时间的基本单位，一个进程可以有多个线程，它们...
thread-test:Java多线程基础
07-20
本篇将深入探讨Java多线程的基础知识，包括线程的创建、同步、生命周期以及线程安全问题。 一、线程的创建 在Java中，有两种主要的方式来创建线程： 1. 继承Thread类：自定义一个类继承Thread类，重写它的run()方法...
《JavaSE》---6.＜基础语法（Java三大程序控制结构）＞
m0_73456341的博客
07-14 812
本篇博客主要讲解Java基础语法中的三大结构，一种顺序结构、两大分支结构i（if-else、swich-case）、四大循环结构（while、do while、fot、foreach）
Spring Security 授权
persistence_PSH的博客
07-14 880
在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。通过 RBAC 获取到用户的具体权限后，再通过 Security 的 用户-权限-资源 来进行权限控制。HttpSecurity 权限配置。
【Go系列】 Sync并发控制
u013379032的博客
07-14 1005
在上一篇文章中，我们介绍了goroutine和channel，理论上，通过channel可以实现并发控制，但是其他语言的开发者可能更习惯一些原子操作的库。当然Go语言也会提供这样的库，所以我们今天了解一下sync库。
接口防刷！利用redisson快速实现自定义限流注解
最新发布
架构师小吴的博客
07-18 823
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
Java多线程基础与实战
本文旨在介绍Java多线程的基础知识，包括线程的实现方式、线程同步以及线程状态等核心概念。" 在Java中，线程是一个程序执行的最小单元，它代表了进程中的单一控制流。与进程相比，线程更加轻量级，因为它们共享...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值