学习Java的多线程以及同步死锁

最新推荐文章于 2024-08-04 11:07:52 发布
最新推荐文章于 2024-08-04 11:07:52 发布
阅读量76 收藏
点赞数 1
分类专栏： 多线程 死锁 线程同步 文章标签： java 学习 jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_55640070/article/details/129893905
版权

Java多线程以及同步死锁

1. 多线程

学习前我们要清楚什么是线程和进程，两者有什么关系？线程是如何创建的，它的作用是什么，它的常用方法是什么？线程的同步和死锁可以解决什么问题。

2. 了解基本的概念：

线程（Thread)：线程是进程中最小的调度的单元（单位），cpu控制的最小的执行单元。轻量级的进程。任何一个程序都至少有一个线程在用，多个线程共享内存。多线程切换消耗的资源少。
进程（Processor)：活动的程序，进程；已经启动，进驻到内存中，正在使用的程序，：进程;每个进程拥有独立的内存空间。
简单举个例子：进程相当于某工厂的某生产车间，线程就是该车间里的流水线。线程和进程的关系,这里我们引入了一个概念同步：
1.一个进程可以有多个线程，但至少有一个线程；而一个线程只能在一个进程的地址空间内活动。
2、资源分配给进程，同一个进程的所有线程共享该进程所有资源。
3、CPU分配给线程，即真正在CPU处理器运行的是线程。
4、线程在执行过程中需要协作同步，不同进程的线程间要利用消息通信的办法实现同步。

3.学习线程的创建办法：

  1. 无返回值创建线程的两种方式：第一种可以去直接继承Thread类，重写run方法，创建线程对象，启动线程（start())对象；第二种可以去实现Runnable接口，重写run方法。具体通过代码：
//继承Thread类
public class MyThread extends Thread{

    public MyThread() {
    }
    public MyThread(String name) {
        super(name); //调用父类构造方法
    }

    @Override
    public void run(){
        for (int i = 0; i <=10; i++) {
            System.out.println(Thread.currentThread().getName()+"在玩游戏"+i);
        }
    }

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
//        myThread.run(); 执行方法，不是 启动线程
        myThread.start();//启动线程

        MyThread1 myThread1 = new MyThread1();
        myThread1.start();

        for (int i = 0; i <=10; i++) {
            System.out.println("主线程执行"+i);
        }
    }
}

//实现Runnable接口，重写run方法
public class MyRun1 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i <=10; i++) {
            System.out.println(Thread.currentThread().getName()+"正在思考");
        }
    }

    public static void main(String[] args) {
        MyRun1 myRun1 = new MyRun1();
        Thread t1 = new Thread(myRun1);
        Thread t2 = new Thread(myRun1);
        t1.start();
        t2.start();
    }
}

通过以上学习，你发现多个线程在执行时，它是没有先后执行顺序的。它由新建进入就绪状态，在运行时它们会抢占Cpu时间片，谁抢到谁先运行，直到进程结束。
学习过程中，大家发现没有run()方法和start()两个方法，这两个方法在线程中的区别如下：

  • t.run() 不会启动线程，只是普通的调用方法而已。不会分配新的分支栈。（这种方式就是单线程。）
  • t.start() 方法的作用是：启动一个分支线程，在JVM中开辟一个新的栈空间，这段代码任务完成之后，瞬间就结束了。这段代码的任务只是为了开启一个新的栈空间，只要新的栈空间开出来，start()方法就结束了。线程就启动成功了。
    启动成功的线程会自动调用run方法，并且run方法在分支栈的栈底部（压栈）。run方法在分支栈的栈底部，main方法在主栈的栈底部。run和main是平级的哈。
  1. 有返回值创建线程时，我们实现Callable接口可以获取线程的返回值，实现Callable接口，要和FutrueTask类连用去获取线程返回值。具体方法如下：
public class MyCall implements Callable<String> {
    @Override
    public String call() throws Exception {
        System.out.println(Thread.currentThread().getName()+"小狗正在吃瓜");
        return "吐出了瓜子";
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyCall call = new MyCall();
//        FutureTask类  获得线程返回值
        FutureTask<String> futureTask = new FutureTask<>(call);
        Thread t1 = new Thread(futureTask);
        t1.start();
        String s = futureTask.get();
        System.out.println("吃完西瓜后：小狗"+s);
    }
}
  1. 学习线程的常用API,这里我们引用一下。

在这里插入图片描述

  1. 了解线程的状态，进行基本的线程调度操作。
  • 线程的五种状态，明白在线程执行时对应的操作是：
    在这里插入图片描述
    体系图看这里：
    在这里插入图片描述
  • 对线程进行调度的基本操作：
    1.调整线程优先级：Java线程有优先级，优先级高的线程会获得较多的运行机会。
public class MyThread extends Thread{

    public MyThread() {
    }
    public MyThread(String name) {
        super(name); //调用父类构造方法
    }

    @Override
    public void run(){
        for (int i = 0; i <=10; i++) {
            System.out.println(Thread.currentThread().getName()+"在玩游戏"+i);
        }
    }

    public static void main(String[] args) {
//    通过构造犯法
        MyThread myThread = new MyThread("西门吹雪");
        myThread.setPriority(Thread.MAX_PRIORITY);//优先级最大为1
        myThread.start();
        System.out.println("优先级1："+myThread.getPriority());
//      主线程优先级 默认为5
        System.out.println(Thread.currentThread().getName()+":"+Thread.currentThread().getPriority());

    }
}

2.线程阻塞
sleep()，线程休眠,会让当前线程处于阻塞状态，指定时间过后，线程就绪状态。yield()暂停当前正在执行的线程对象，并执行其他线程，yield()方法不是阻塞方法。让当前线程让位，让给其它线程使用。join()方法，等待其他线程终止。在当前线程中调用另一个线程的join()方法，则当前线程转入阻塞状态，直到另一个进程运行结束，当前线程再由阻塞转为就绪状态。interrupt:中断线程，仅仅发送了一个中断的信号，当碰到wait(),sleep方法时，清除中断标记，抛出异常。setDaemon:设置线程为后台（守护）线程。

  1. 了解多线程数据安全问题：
    以后在开发中，我们的项目都是运行在服务器当中，而服务器已经将线程的定义，线程对象的创建，线程的启动等，都已经实现完了。这些代码我们都不需要编写。
    最重要的是： 你要知道，你编写的程序需要放到一个多线程的环境下运行，你更需要关注的是这些数据在多线程并发的环境下是否是安全的。以下可能会产生数据安全问题：
  • 条件1：多线程并发。
  • 条件2：有共享数据。
  • 条件3：共享数据有修改的行为。

我们举例子来验证，例如：我和其余两位同时取一个账户的钱，我取钱后数据还没返回给服务器，两位同学依次再取，这个时候显示的余额为后面同学取钱的余额。显然这样不对，我们如何解决？线程排队执行？用线程同步，使用Synchronized同步实现？大家可以理解一下锁：
Lock是显示锁，需要自己手动开启和关闭，synchronized是隐式锁，出了作用于自动释放，无需自己释放。
Lock只能锁代码块，synchronized可以锁代码块和方法，使用Lock锁，JVM将花费更少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）

//建立一个账户类，写一个取钱方法
public class Account {
    private String no;//账号
    private double money;//金额

    public Account() {
    }

    public Account(String no, double money) {
        this.no = no;
        this.money = money;
    }

    private Lock lock = new ReentrantLock(); //创建锁对象

    public void getMoney(double m){

        synchronized (this){ //利用同步，解决多线程安全问题
            double before = this.money;
            double after = before - m;
            lock.lock();  //上锁
            try {
                Thread.sleep(300); //线程休眠
            } catch (InterruptedException e) {
                System.out.println(e.getMessage());
            } finally {
                lock.unlock();//关锁
            }
            this.money = after;
            System.out.println(Thread.currentThread().getName()+"取钱："+ m + "余额:" + this.money);
        }
    }
}

写Thread继承类，重写run()方法，写测试类进行测试。

public class AccountThread extends Thread {
    private Account account;

    public AccountThread(Account account){
        this.account = account;
    }

    @Override
    public void run() {
        account.getMoney(500);
    }

    public static void main(String[] args) throws InterruptedException {
        Account account = new Account("123456", 3000);
        AccountThread t1 = new AccountThread(account);
        AccountThread t2 = new AccountThread(account);
        AccountThread t3 = new AccountThread(account);
        t1.start();
        t2.start();
        t3.start();
    }
}

结果：
请添加图片描述

  1. 死锁：当多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能进行，从而导致两个或者多个线程都在等待对方释放资源，都停止执行的情况。最简单的，让某一个同步块同时拥有“两个以上的对象的锁”的时候，就可能会发生死锁问题，这个时候就引入一个经典案列：哲学家就餐问题。解决该问题上锁，要求尽量不要让 一个同步代码块 同时拥有“两个以上的对象的锁”，实例如下：
//定义生产者消费者
public class Producer extends Thread {
    private Stock stock;

    public Producer(Stock stock) {
        this.stock = stock;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            stock.push();
        }
    }
}

public class Customer extends Thread{
    private Stock stock;

    public Customer(Stock stock) {
        this.stock = stock;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            stock.pop();
        }
    }
}
//解决生产者消费者问题，方法1上Stock锁。
public class Stock {
    private int count = 0;//库存
//    生产
    public synchronized void push(){
        if(count<10){
            count++;
            this.notifyAll();
            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"库存不足，开始生产棒棒糖"+count);
        }else{
            System.out.println(Thread.currentThread().getName()+"库存已足，停止生产");
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
//    消费
    public synchronized void pop(){
        if(count>0){
            count--;
            this.notifyAll();
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"库存足够，消费一个棒棒糖"+count);
        }else{
            System.out.println(Thread.currentThread().getName()+"库存不足，继续生产");
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {
        Stock stock = new Stock();
        Producer producer1 = new Producer(stock);
        Producer producer2 = new Producer(stock);
        Customer customer1 = new Customer(stock);
        Customer customer2 = new Customer(stock);
        Customer customer3 = new Customer(stock);
        producer1.start();
        producer2.start();
        customer1.start();
        customer2.start();
        customer3.start();

    }
}

//方法2：写一个阻塞队列，确定生产消费长度
//实现Runnable接口，用put()和take()方法。
public class ArrayBq {
    public static void main(String[] args) {
//        阻塞队列：
        BlockingQueue<Integer> queue =  new ArrayBlockingQueue<>(10);
        Thread prouder = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    try {
                        queue.put(i);
                        System.out.println("生产牛肉："+i);
//                        Thread.sleep(20);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });


        Thread customer = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    try {
                      int values =  queue.take();
                        System.out.println("消费牛肉：" + values);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });

        prouder.start();
        customer.start();
    }
}

学到这里本篇就结束了，感谢大家阅览！

资产今日进账
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程：线程同步详解
流楚丶格念的博客
07-16 3108
线程死锁是指由于两个或者多个线程互相持有对方所需要的资源，导致这些线程处于等待状态，无法前往执行。
Java多线程 线程同步与死锁
08-30
Java多线程 线程同步与死锁 Java多线程是一种编程技术，允许多个线程同时执行，以提高程序的执行效率和响应速度。但是，多线程编程也存在一些安全问题，例如线程同步和死锁问题。 线程同步是指多个线程之间的协作...
Java多线程并发访问同步代码块：Lock使用简述
hills的专栏
05-15 435
Java多线程并发访问同步代码块：Lock使用简述
Java多线程——死锁
u010759175的专栏
12-28 1104
话不多说先来个例子说明 灰姑娘和白雪公主化妆，但是同时拿着对方的资源不释放，形成了僵持的局面 //死锁：多个线程互相抱着对方需要的资源，形成僵持 public class DeadLock { public static void main(String[] args) { MakeUp m1 = new MakeUp(0,"灰姑娘"); MakeUp m2 = new MakeUp(1,"白雪公主"); m1.start(); m2.start(); } } //口红 class
Java多线程学习（吐血超详细总结）
热门推荐
Evankaka的专栏
03-14 41万+
本文主要讲了java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。
Java多线程：死锁
weixin_55305220的博客
12-09 1158
一、死锁的定义 多线程以及多进程改善了系统资源的利用率并提高了系统 的处理能力。然而，并发执行也带来了新的问题——死锁。所谓死锁是指多个线程因竞争资源而造成的一种僵局（互相等待），若无外力作用，这些进程都将无法向前推进。 所谓死锁是指两个或两个以上的线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。 下面我们通过一些实例来说明死锁现象。 先看生活中的一个实例，两个人面对面过独木桥，甲和乙都已经在桥上走了一段距离，即占用了桥...
Java多线程-死锁的出现和解决
2401_84408734的博客
04-18 1028
很多人感叹“学习无用”，实际上之所以产生无用论，是因为自己想要的与自己所学的匹配不上，这也就意味着自己学得远远不够。无论是学习还是工作，都应该有主动性，所以如果拥有大厂梦，那么就要自己努力去实现它。最后祝愿各位身体健康，顺利拿到心仪的offer！由于文章的篇幅有限，所以这次的蚂蚁金服和京东面试题答案整理在了PDF文档里《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
Java多线程——死锁的成因与解决
weixin_60778429的博客
08-02 2444
死锁是指两个或者两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造的一种阻塞的现象，若无外力作用，他们都将无法推进下去。. 假设有 N 个线程尝试获取 M 把锁, 就可以针对 M 把锁进行编号 (1, 2, 3...M). N 个线程尝试获取锁的时候, 都按照固定的按编号。即存在一个等待队列：P1占有P2的资源，P2占有P3的资源，P3占有P1的资源。当然预防出现死锁的方法不止一种，我们只是讲了一种比较简单易懂的方法。的进程称为死锁进程。即当资源请求者在请求其他的资源的同时保持对原有资源的占有。.
Java 多线程 —— 同步代码块（解决线程安全问题)
一纸春秋的博客
10-23 1万+
目录火车站抢票问题同步代码块同步方法（this锁）同步方法，在public的后面加上synchronized关键字this锁静态同步方法 火车站抢票问题 由于现实中买票也不会是零延迟的，为了真实性加入了延迟机制，也就是线程休眠语句 package test.MyThread.ticketDemo; public class RunnableThread implements Runnable{ private int ticket = 100; @Override public v
万字图解Java多线程
qq_35598736的博客
09-06 6万+
前言 java多线程我个人觉得是javaSe中最难的一部分，我以前也是感觉学会了，但是真正有多线程的需求却不知道怎么下手，实际上还是对多线程这块知识了解不深刻，不知道多线程api的应用场景，不知道多线程的运行流程等等，本篇文章将使用实例+图解+源码的方式来解析java多线程。 文章篇幅较长，大家也可以有选择的看具体章节，建议多线程的代码全部手敲，永远不要相信你看到的结论，自己编码后运行出来的，才是自己的。 什么是java多线程? 进程与线程 进程 当一个程序被运行，就开启了一个进程， 比如启动了qq，w.
java多线程学习之死锁的模拟和避免(实例讲解)
08-30
Java 多线程学习之死锁的模拟和避免是 Java 并发编程中非常重要的一个 topic。下面我们将对死锁的概念、产生的必要条件、模拟死锁的实例以及避免死锁的方法进行详细的讲解。 死锁 死锁是多个线程同时被阻塞，它们...
Java多线程学习总结
09-14
Java多线程是编程中的重要概念，尤其在开发高并发、高性能的应用时不可或缺。本文将深入探讨Java中的线程和进程，以及如何在Java中实现多线程。 首先，理解线程和进程的概念至关重要。线程是操作系统分配CPU时间片...
Java多线程-线程的同步与锁的问题
09-01
Java多线程编程中，线程同步是一种解决并发问题的关键技术。当多个线程同时访问共享资源时，可能会引发数据不一致性和竞态条件。线程同步的主要目标是确保同一时间只有一个线程能够访问特定的代码段，以避免数据损坏...
详解Java的线程的优先级以及死锁
09-03
理解并妥善处理线程优先级和死锁是Java多线程编程的关键，这有助于编写出更加高效、安全的并发应用程序。在实际开发中，应遵循良好的并发编程实践，避免因不当使用线程同步而导致的性能问题和异常情况。
枚举工具类
qq_43049583的博客
08-04 303
java枚举工具类
等待唤醒机制两种实现方法-阻塞队列
最新发布
泰勒今天想展开的博客
08-04 343
桌子上有面条-》吃货执行桌子上没面条-》生产者制造执行。
社区养老服务小程序的设计
Karen198的博客
07-31 671
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
深入理解Java注解
weixin_55745942的博客
08-01 674
Java注解是用来描述程序元素（如类、方法、变量等）的一种机制。它们可以提供关于程序的补充信息，帮助编译器、框架或其他工具更好地理解和处理代码。注解通常以符号开头，后跟注解名称和可能的参数。要创建自定义注解，需要使用@interface关键字定义一个接口，并在接口中声明注解的属性。这个注解名为，可以被用来标记方法。它有一个名为value的属性，具有默认值"default"。
Java多线程同步与死锁详解
本资源主要聚焦于Java语言的同步与死锁概念以及相关的语法总结。在多线程编程中，Java通过...综上，本资源详细梳理了Java语言的关键语法和并发控制，为理解和解决多线程编程中的同步与死锁问题提供了全面的指南。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值