Java多线程04：线程优先级、守护线程和线程同步

合集 - Java(30)

1.Java入门——介绍及安装2022-03-05 2.Java基础01：注释、标识符、数据类型2022-03-05 3.Java基础02：类型转换、变量、常量2022-03-06 4.Java基础03：基本运算符2022-03-07 5.Java基础04：包机制、JavaDoc生成文档2022-03-08 6.Java流程控制01：Scanner对象2022-03-08 7.Java流程控制02：顺序结构和选择结构2022-03-09 8.Java流程控制03：循环结构2022-03-10 9.Java方法2022-03-11 10.Java数组01：数组的定义、声明、创建、初始化和内存分析2022-03-12 11.Java数组02：数组使用、多维数组、冒泡排序和稀疏数组2022-03-13 12.Java面向对象01：类与对象的关系、创建和初始化对象2022-03-14 13.Java面向对象02：封装和继承2022-03-15 14.Java面向对象03：抽象类、接口和内部类2022-03-17 15.Java异常2022-03-17 16.SpringBoot和微服务架构2022-03-17 17.SpringBoot基础01：创建项目和编写HTTP接口2022-03-19 18.SpringBoot基础02：自动装配原理、yaml语法和JSR-303数据校验2022-03-20 19.SpringBoot基础03：静态资源和首页定制2022-03-24 20.Java多线程01：什么是线程和线程的创建2022-03-25 21.Java多线程02：静态代理模式和Lambda表达式2022-03-27 22.Java多线程03：线程的五大状态2022-03-28

23.Java多线程04：线程优先级、守护线程和线程同步2022-03-29

24.Java多线程05：死锁、LOCK和线程协作2022-03-30 25.网络编程基础01：网络编程概述、IP和端口2022-04-02 26.网络编程基础02：TCP实现聊天和文件上传2022-04-06 27.Java注解和反射01：注解2022-04-06 28.Java注解和反射02：反射基本概述和获得Class类的几种方式2022-05-17 29.Java注解和反射03：类加载2022-05-18 30.Java注解和反射04：Class对象的使用2022-05-19

Java多线程04：线程优先级、守护线程和线程同步

线程优先级

Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行
线程的优先级用数字表示，范围从0~10
- Thread.Min_PRIORITY = 1;
- Thread.MAX_PRIORITY = 10;
- Thread.NORM_PRIORITY = 5;
使用以下方式改变或获取优先级
- getPriority()、setPriority(int xxx)

实例：

package com.lurenj.thread;

public class TestPriority {

    public static void main(String[] args) {

        MyPriority myPriority = new MyPriority();

        Thread t1 = new Thread(myPriority);
        Thread t2 = new Thread(myPriority);
        Thread t3 = new Thread(myPriority);
        Thread t4 = new Thread(myPriority);
        Thread t5 = new Thread(myPriority);
        Thread t6 = new Thread(myPriority);

        //设置优先级再启动
        t1.start();

        t2.setPriority(1);
        t2.start();

        t3.setPriority(4);
        t3.start();

        t4.setPriority(10);
        t4.start();

        t5.setPriority(3);
        t5.start();

        t6.setPriority(6);
        t6.start();
        //主线程默认优先级
        System.out.println(Thread.currentThread().getName() + "-->" + Thread.currentThread().getPriority());

    }

}

class MyPriority implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "-->" + Thread.currentThread().getPriority());
    }
}

守护（daemon）线程

线程分为用户线程 和守护线程
虚拟机必须确保用户线程执行完毕
虚拟机不用等待守护线程执行完毕，如：后台记录操作日志、监控内存、垃圾回收等

实例

package com.lurenj.thread;

public class TestDaemon {
    public static void main(String[] args) {
        God god = new God();
        You2 you2 = new You2();

        Thread thread = new Thread(god);
        thread.setDaemon(true);//默认是false表示是用户线程，正常的线程都是用户线程
        thread.start();//守护线程启动

        new Thread(you2).start();


    }
}



//God

class God implements Runnable{
    @Override
    public void run() {
        while (true){
            System.out.println("保佑着你~");
        }
    }
}


//你
class You2 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 36500; i++) {
            System.out.println("一生都开心的活着~");
        }
        System.out.println("========goodbye!=========");
    }
}

线程同步机制

并发：同一个对象被多个线程同时操作
线程同步：处理多线程问题时，多个线程访问同一个对象（并发） ，并且某些线程还想修改这个对象，这时候我们就需要线程同步，线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池 形成队列，等待前面线程使用完毕，下一个线程再使用。
线程同步形成条件：队列+锁
- 由于同一进程的多个线程共享同一块储存空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入锁机制（synchronized） ，当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可
线程同步存在的问题：
- 一个线程持有锁会导致其他所有需要此锁的线程挂起；
- 在多线程竞争下，加锁、释放锁会导致比较多的上下文切换和调度延迟，引起性能问题；
- 如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置，引起性能问题；

三大不安全案例

案例一：买票不安全，会出现重复或-1

package com.lurenj.syn;

//不安全的买票
//线程不安全，有负数和重复购买
public class UnsafeTicket {
    public static void main(String[] args) {
        BuyTicket station = new BuyTicket();

        new Thread(station,"kubi").start();
        new Thread(station,"niubi").start();
        new Thread(station,"huangniu").start();
    }

}

class BuyTicket implements Runnable{

    //车票
    private int ticketNums = 10;
    private boolean flag = true;//外部停止
    @Override
    public void run() {
        while (flag){
            buy();
        }

    }

    private void buy(){
        //判断是否有票
        if (ticketNums <= 0){
            flag = false;
            return;
        }
        //模拟延时
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //买票
        System.out.println(Thread.currentThread().getName() + "拿到了" + ticketNums--);
    }
}

案例二：数组不安全，输出错误

package com.lurenj.syn;

import java.util.ArrayList;
import java.util.List;

public class UnsafeList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        System.out.println(list.size());
    }
}

案例三：银行取钱不安全，出现负数或者取出总额大于存款

package com.lurenj.syn;

import com.lurenj.oop.demo05.A;

//不安全的取钱
public class UnsafeBank {
    public static void main(String[] args) {
        //账户
        Account account = new Account(100,"结婚基金");

        Drawing you = new Drawing(account,50,"你");
        Drawing girlfriend = new Drawing(account,100,"女友");

        you.start();
        girlfriend.start();
    }
}

//账户
class Account{
    int money;//余额
    String name;//卡名

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}

//银行：模拟取款
class Drawing extends Thread{
    Account account;//账户
    int drawingMoney;//取了多少钱
    int nowMoney;//现在手头的钱

    public Drawing(Account account, int drawingMoney, String name){
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
    }

    //取钱
    @Override
    public void run() {
        //判断是否有钱
        if (account.money - drawingMoney < 0){
            System.out.println(this.getName() + "钱不够，取不了");
            return;
        }

        //sleep可以放大问题的发生性
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        account.money = account.money - drawingMoney;
        nowMoney += drawingMoney;
        System.out.println(account.name + "余额为：" + account.money);
        //Thread.currentThread().getName() = this.getName()，因为该类继承了Thread类，getName是其中的方法
        System.out.println(this.getName() + "手里的钱" + nowMoney);
    }
}

同步方法

由于我们可以通过private关键字来保证数据对象只能被方法访问，所以我们只需要针对方法提出一套机制，这套机制就是synchronized关键字，它包括两种方法：synchronized方法和synchronized块。

同步方法：public synchronized void method(int args){}
synchronized方法控制对”对象“的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行。

缺陷：若将一个大的方法声明为synchronized将会影响效率；方法里面需要修改的内容才需要锁，锁的太多，浪费资源

同步块

同步块：synchronized(Obj){}
Obj称之为同步监视器
- Obj可以是任何对象，但是推荐使用共享资源作为同步监视器
- 同步方法无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身，或者是class[反射中讲解]
同步监视器的执行过程
1. 第一个线程访问，锁定同步监视器，执行其中代码
2. 第二个线程访问，发现同比福建神器别锁定，无法访问
3. 第一个线程访问完毕，解锁同步监视器
4. 第二个线程访问，发现同步监视器没有锁，然后锁定并访问

实例一：解决买票不安全

package com.lurenj.syn;

//不安全的买票
//线程不安全，有负数和重复购买
public class UnsafeTicket {
    public static void main(String[] args) {
        BuyTicket station = new BuyTicket();

        new Thread(station,"kubi").start();
        new Thread(station,"niubi").start();
        new Thread(station,"huangniu").start();
    }

}

class BuyTicket implements Runnable{

    //车票
    private int ticketNums = 10;
    private boolean flag = true;//外部停止
    @Override
    public void run() {
        while (flag){
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

    //synchronized 同步方法，锁的是this
    private synchronized void buy() throws InterruptedException {//在此处添加synchronized，就解决了
        //判断是否有票
        if (ticketNums <= 0){
            flag = false;
            return;
        }
        //模拟延时
            Thread.sleep(100);
        //买票
        System.out.println(Thread.currentThread().getName() + "拿到了" + ticketNums--);
    }
}

实例二：解决银行取钱不安全

package com.lurenj.syn;

import com.lurenj.oop.demo05.A;

//不安全的取钱
public class UnsafeBank {
    public static void main(String[] args) {
        //账户
        Account account = new Account(1000,"结婚基金");

        Drawing you = new Drawing(account,50,"你");
        Drawing girlfriend = new Drawing(account,100,"女友");

        you.start();
        girlfriend.start();
    }
}

//账户
class Account{
    int money;//余额
    String name;//卡名

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}

//银行：模拟取款
class Drawing extends Thread{
    Account account;//账户
    int drawingMoney;//取了多少钱
    int nowMoney;//现在手头的钱

    public Drawing(Account account, int drawingMoney, String name){
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
    }

    //取钱
    //synchronized默认锁的是this，这里默认锁是<银行：模拟取款>，而我们实际需要锁的是<账户>
    @Override
    public void run() {

        synchronized (account){

            //判断是否有钱
            if (account.money - drawingMoney < 0){
                System.out.println(this.getName() + "钱不够，取不了");
                return;
            }

            //sleep可以放大问题的发生性
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            account.money = account.money - drawingMoney;
            nowMoney += drawingMoney;
            System.out.println(account.name + "余额为：" + account.money);
            //Thread.currentThread().getName() = this.getName()，因为该类继承了Thread类，getName是其中的方法
            System.out.println(this.getName() + "手里的钱" + nowMoney);
        }
    }
}

案例三：解决数组不安全问题

package com.lurenj.syn;

import java.util.ArrayList;
import java.util.List;

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

        List<String> list = new ArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                synchronized (list){//通过锁住list对象来解决
                    list.add(Thread.currentThread().getName());
                }
            }).start();
        }
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

案例四：解决数组不安全问题方法二，通过CopyOnWriteArrayList方法

package com.lurenj.syn;

import java.util.concurrent.CopyOnWriteArrayList;

//测试JUC安全类型的集合
public class TestJUC {
    public static void main(String[] args) {
        CopyOnWriteArrayList list = new CopyOnWriteArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

posted @ 2022-03-29 22:19 lurenj 阅读(56) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· Java多线程01：什么是线程和线程的创建

· Java多线程03：线程的五大状态

· 多线程Day03

· 线程的优先级，守护线程

· 【学习笔记】线程（五）线程优先级、守护线程

阅读排行：
· 无需6万激活码！GitHub神秘组织3小时极速复刻Manus，手把手教你使用OpenManus搭建本
· Manus爆火，是硬核还是营销？
· 终于写完轮子一部分：tcp代理了，记录一下
· 别再用vector＜bool＞了！Google高级工程师：这可能是STL最大的设计失误
· 单元测试从入门到精通

公告

昵称： lurenj
园龄： 3年
粉丝： 0
关注： 0

+加关注

2025年3月

日

一

二

三

四

五

六

lurenj

高可用、高性能、高并发

Java多线程04：线程优先级、守护线程和线程同步

Java多线程04：线程优先级、守护线程和线程同步

线程优先级

守护（daemon）线程

线程同步机制

三大不安全案例

案例一：买票不安全，会出现重复或-1

案例二：数组不安全，输出错误

案例三：银行取钱不安全，出现负数或者取出总额大于存款

同步方法

同步块

实例一：解决买票不安全

实例二：解决银行取钱不安全

案例三：解决数组不安全问题

案例四：解决数组不安全问题方法二，通过CopyOnWriteArrayList方法

公告

搜索

常用链接

合集

随笔分类

随笔档案

阅读排行榜