线程优先级；守护线程；线程同步(synchronized)；死锁；Lock；管程法；线程池

最新推荐文章于 2022-08-14 21:59:55 发布
最新推荐文章于 2022-08-14 21:59:55 发布
阅读量108 收藏
点赞数
分类专栏： java多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45964083/article/details/115666413
版权

线程优先级

优先级高，只是意味着获得调度的概率高，并不是一定首先被CPU调度

public class TestPriority {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
        MyPriority myPriority = new MyPriority();

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

        //先设置优先级，再启动
        t1.start();   //默认为5;

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

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

        t4.setPriority(Thread.MAX_PRIORITY);  //虽然优先级最高但不一定优先执行
        t4.start();
    }
}
class MyPriority implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
    }
}

守护线程（daemon）

  • 线程分为用户线程和守护线程
  • 虚拟机必须确保用户线程执行完毕
  • 虚拟机不用等待守护线程执行完毕，如后台记录操作日志，垃圾回收线程（gc），监控内存
public class TestDaemon {
    public static void main(String[] args) {
        
    
     God god=new God();
     Ou ou =new Ou();
     Thread thread = new Thread(god);
        
     thread.setDaemon(true);
    
     thread.start();
     
     new Thread(ou).start();

}}
//上帝
class God implements Runnable{

    @Override
    public void run() {
        while (true){
            System.out.println("守护");
        }
    }
}
//你
class Ou implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 36500; i++) {
            System.out.println("快乐活着");
        }
        System.out.println("goodbye");
    }
}

线程同步

并发：同一个对象被多个线程同时操作

当并发时如果某些线程想修改这个对象，就需要线程同步，这其实就是一种等待机制，这些线程需要进入这个对象的等待池形成队列，前面线程使用完毕，下一个线程再使用。

线程同步的形成条件：队列+锁

锁机制（synchronized）每一个对象都有一把锁，synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，后面被阻塞的线程才能获得这个锁，继续执行。

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

加上synchronized这个关键字就会变成同步方法。

synchronized默认锁的是this. 就是这个对象本身，或者是这个方法本身的类

有两种形式：
1. synchronized同步方法，锁的是这个方法本身的类
2. synchronized同步块，可以锁任何对象，锁的对象是变化的量，就是增删改的对象。比如锁银行这个类没用，所以不能用同步方法，要用同步块锁账户。

买票这个例子要锁买票这个方法。也就是买票这个类。所以可以直接用同步方法（用关键字直接修饰方法即可）：
private synchronized void buy() throws InterruptedException {
}

public class UnsafeBuyTicket {
   public static void main(String[] args) {
       BuyTicket station = new BuyTicket();

       new Thread(station,"小白").start();
       new Thread(station,"小黑").start();
       new Thread(station,"小红").start();

   }
}

class BuyTicket implements Runnable{

   private int ticketNums = 10;
   boolean flag = true;

   @Override
   public void run() {
       //买票
       while (flag){
           try {
               buy();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }

   }

   private synchronized void buy() throws InterruptedException {
       //判断是否有票
       if(ticketNums<=0){
           flag=false;
           return;
       }
       Thread.sleep(100);
       System.out.println(Thread.currentThread().getName()+"拿到了"+ticketNums--);
   }
}

银行取钱这个例子如果对run这个方法用synchronized锁的是这个类，也就是Drawing，锁的是银行，但银行是不变的，应该锁账户，所以应该用同步块，锁用户，而不是同步方法。
直接用synchronized（account）{run方法的内容}

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() {
        synchronized (account){
            //判断有没有钱
            if(account.money-drawingMoney<0){
                System.out.println(Thread.currentThread().getName()+"钱不够，取不了");
                return;
            }
            //卡内的钱
            account.money = account.money-drawingMoney;
            //你手里的钱
            nowMoney=nowMoney+drawingMoney;
            System.out.println(account.name+"余额为:"+account.money);
            System.out.println(this.getName()+"手里的钱："+nowMoney);
        }
    }
}

死锁

死锁：多个线程互相抱着对方需要的资源，然后形成僵持。
导致两个或者多个线程都在等待对方释放资源，都会停止执行的情况，某一个同步快同时拥有“两个以上对象的锁”时，就可能会发生“死锁”的情况

例子：

public class DeakLock {
    public static void main(String[] args) {
        Makeup g1=new Makeup(0,"小红");
        Makeup g2=new Makeup(1,"小黑");

        g1.start();
        g2.start();
    }
}

//口红
class Lipstick{

}

//镜子
class Mirror {

}

class Makeup extends Thread{

    //需要的资源只有一份，用static来保证一份
    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();

    int choice ;//选择
    String girlName;
    Makeup (int choice,String girlName){
        this.choice=choice;
        this.girlName=girlName;
    }
    @Override
    public void run() {

        //化妆
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
    //化妆，互相持有对方的锁，就是需要拿到对方的资源
    private void makeup() throws InterruptedException {
        if(choice == 0){
            synchronized (lipstick){//获得口红的锁
                System.out.println(this.girlName+"获得口红的锁");
                Thread.sleep(1000);
                synchronized (mirror){//一秒钟后获得镜子
                    System.out.println(this.girlName+"获得镜子的锁");
                }
            }

        }else{
            synchronized (mirror){//获得镜子的锁
                System.out.println(this.girlName+"获得镜子的锁");
                Thread.sleep(2000);
                synchronized (lipstick){//两秒钟后获得口红
                    System.out.println(this.girlName+"获得口红的锁");
                }
            }
        }
    }
}

在这里插入图片描述
输出结果不对，只需将锁拿出来即可，不能报对方的锁

//化妆，互相持有对方的锁，就是需要拿到对方的资源
    private void makeup() throws InterruptedException {
        if(choice == 0){
            synchronized (lipstick){//获得口红的锁
                System.out.println(this.girlName+"获得口红的锁");
                Thread.sleep(1000);
            }
            synchronized (mirror){//一秒钟后获得镜子
                System.out.println(this.girlName+"获得镜子的锁");
            }

        }else{
            synchronized (mirror){//获得镜子的锁
                System.out.println(this.girlName+"获得镜子的锁");
                Thread.sleep(2000);
            }
            synchronized (lipstick){//两秒钟后获得口红
                System.out.println(this.girlName+"获得口红的锁");
            }
        }
    }

在这里插入图片描述

Lock(锁)

ReentrantLock（可重入锁）类实现了Lock
对比：

  • Lock锁是显式锁（手动开启，关闭），synchronized是隐式锁，出了作用域自动释放
  • Lock只有代码块锁，synchronized有代码块锁和方法锁
  • 使用Lock锁，JVM将花费较少时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）
    在这里插入图片描述

生产者/消费者模式->管程法

//测试：生产者消费者模型-->利用缓冲区解决：管程法
//生产者，消费者，产品。缓冲区
public class TestPC {
    public static void main(String[] args) {
        SynContainer container = new SynContainer();
        new Producter(container).start();
        new Consumer(container).start();
    }
}

//生产者
class Producter extends Thread{
    SynContainer container;

    public Producter(SynContainer container){
        this.container=container;
    }
//生产
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {

            container.push(new Chicken(i));
            System.out.println("生产了"+i+"只鸡");
        }
    }
}
//消费者
class Consumer extends  Thread{
    SynContainer container;

    public Consumer(SynContainer container){
        this.container=container;
    }
//消费
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("消费了-->"+container.pop().id+"只鸡");
        }
    }
}

//产品
class Chicken{
    int id;

    public Chicken(int id) {
        this.id = id;
    }
}

//缓冲区
class SynContainer {
    //需要一个容器大小
    Chicken[] chickens=new Chicken[10];
    //容器计数器
    int count;

    //生产者放入产品
    public synchronized void push(Chicken chicken){
        //如果容器满了，就等待消费者消费
        if(count==chickens.length){
            //通知消费者消费，生产等待
            try{
                this.wait();
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
        //如果没有满就需要丢入产品
        chickens[count]=chicken;
        count++;

        //可以通知消费者消费了
       this.notifyAll();

    }
   // 消费者消费产品
    public synchronized Chicken pop(){
        //判断是否消费
        if(count==0){
            //等待生产者生产，消费者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果可以消费
        count--;
        Chicken chicken = chickens[count];

        //通知生产者生产
        this.notifyAll();
        return chicken;
    }
}

线程池

经常创建和销毁、使用特别大的资源，比如并发情况下的线程，对性能影响很大，提前创建好多个线程，放入线程池冲，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具

//测试线程池
public class TestPool {
    public static void main(String[] args) {


        //创建服务，创建线程池  newFixedThreadPool参数为线程池的大小
        // ExecutorService是真正的线程池接口，需要通过Executors创建线程池的大小
        ExecutorService service = Executors.newFixedThreadPool(10);
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        
        //2.关闭连接
        service.shutdown();
    }
}

class MyThread implements Runnable{

    @Override
    public void run() {
            System.out.println(Thread.currentThread().getName());
    }
}
大吖么大白菜
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java多线程编程之使用Synchronized关键字同步类方法
09-04
JAVA中要想解决“脏数据”的问题，最简单的方法就是使用synchronized关键字来使run方法同步,看下面的代码，只要在void和public之间加上synchronized关键字
一、Synchronized详解与锁升级
余笙的博客
08-22 601
对象头（Header）、实例数据（Instance Data）和对齐填充（Padding）Mark Word被设计成一个有着动态定义的数据结构，以便在极小的空间内存储尽量多的数据，根据对象的状态复用自己的存储空间，也就是说在运行期间MarkWord里存储的数据会随着锁标志位的变化而变化无锁9、重量级锁/*** 验证当一个对象计算过hashcode时，它就无法进入到偏向锁状态，* 跳过偏向锁，直接升级为轻量级锁。...
java_线程优先级、Synchronized和Reentrantlock区别、sleep和wait区别、死锁
qq_59727955的博客
08-14 291
多线程的优先级、Synchronized和Reentrantlock区别、sleep和wait区别、死锁
（七）线程的优先级Priority和关键词：synchronized
Java程序源
06-03 333
线程执行顺序，其实就是看谁先争夺到资源，那么有没有办法改变这种机制呢？ 答案是，有的，但是也只是干预，并不是说不让他们去争夺资源。 那就是使用了：线程优先级 同时我们也简单了解一下 synchronized 这个关键词，了解一下他的特性和简单用法等。 package com.zmkj.admin.test; import lombok.SneakyThrows; /** * 线程优先级 * * 温习一下线程的几种状态： * 新建(NEW)、可运行(RUNNABLE)、运行(RUNNING)、阻
java线程等待、设置优先级、同步、挂起、恢复(Join、setPriority、synchronized、wait、notify……)
foart的专栏
12-16 5553
一、线程等待Join示例//代码来源：JBuilder9程序设计--java程序员成功之路      P230 class NewThread implements Runnable{       String name;       Thread t;       NewThread(String threadname){           name=threadname;      
Synchronized 机制深度分析
shine的博客
09-30 2460
Synchronized 在Java中存在两种锁机制：synchronized和Lock，Lock接口及其实现类是JDK5增加的内容，其作者是大名鼎鼎的并发专家Doug Lea。本文并不比较synchronized与Lock孰优孰劣，只是介绍二者的实现原理。       数据同步需要依赖锁，那锁的同步又依赖谁？synchronized给出的答案是在软件层面依赖JVM，而Lock给出的方案是在硬...
java多线程编程之使用Synchronized块同步方法
09-04
synchronized块来同步一个对象变量,也可以使用synchronized块来同步类中的静态方法和非静态方法,下面使用Synchronized块同步方法
java多线程编程之使用Synchronized块同步变量
09-04
我们可以通过synchronized块来同步特定的静态或非静态方法。要想实现这种需求必须为这些特性的方法定义一个类变量，然后将这些方法的代码用synchronized块括起来，并将这个类变量作为参数传入synchronized块
Java使用synchronized修饰方法来同步线程的实例演示
09-02
synchronized下的方法控制多线程程序中的线程同步非常方便,这里就来看一下Java使用synchronized修饰方法来同步线程的实例演示,需要的朋友可以参考下
Java线程之线程同步synchronized和volatile详解
08-28
主要介绍了Java线程之线程同步synchronized和volatile详解，具有一定参考价值，需要的朋友可以了解下。
java并发系列：深入分析Synchronized
bohu83的博客
04-13 5922
本文属于并发编程网聊聊并发的学习笔记系列，作者是方腾飞大神，本文在基本上忠于原文，为了便于像我这样的不懂这块的同学更好理解，在原文基础上适当调整。 为尊重原著大神：特意贴出原文地址：http://ifeve.com/java-synchronized/ 1术语： CAS：Compare and Swap，比较并设置。用于在硬件层面上提供原子性操作。在 Intel 处理器中，比较并交换通过指令
Java基础语法-线程优先级和守护(daemon)线程
有过执着才能放下执着的博客
05-25 184
1.Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行。 2.线程的优先级用数字表示，范围从1~10. Thread.MIN_PRIORITY = 1; Thread.NORM_PRIORITY = 5; Thread.MAX_PRIORITY = 10; 3.使用以下方式改变或者获取优先级 getPriority(); setPriority(int newPriority); 代码如下： public class Prio
进程、线程、协程和管程的区别
love10_1314的博客
07-25 3337
大家都知道，计算机是为了模拟现实世界，其中计算机领域最伟大的发明之一就是操作系统。操作系统对于计算机来说是其核心的存在，可以说操作系统的地位就像计算机的灵魂一样。操作系统的诞生是为了运行用户程序，事实上程序运行在操作系统上就变成了进程，现在就来让我们一起了解一下进程相关的内容。 进程 根据理解，我们可以对进程下个定义——进程是运行中的程序。注意，进程是一个动态的概念，这一点很重要。但是进程并不是那...
线程优先级及守护(daemon)线程
weixin_46649583的博客
10-10 114
线程优先级 Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行。 线程的优先级用数字表示，范围从1~10. Thread.MIN_PRIORITY = 1; Thread.MAX_PRIORITY = 10; Thread.NORM_PRIORITY = 5; 使用以下方式改变或获取优先级 getPriority() setPriority(int xxx) 注意：优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调用，
synchronized用法
一花一世界 一叶一菩提
08-01 292
参考地址：http://blog.csdn.net/luoweifu/article/details/46613015synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种：<1> 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象； <2>修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法
深入JVM锁机制1-synchronized
SAN_YUN的专栏
07-07 1761
目前在Java中存在两种锁机制：synchronized和Lock，Lock接口及其实现类是JDK5增加的内容，其作者是大名鼎鼎的并发专家Doug Lea。本文并不比较synchronized与Lock孰优孰劣，只是介绍二者的实现原理。    数据同步需要依赖锁，那锁的同步又依赖谁？synchronized给出的答案是在软件层面依赖JVM，而Lock给出的方案是在硬件层面依赖特殊的CPU指令...
Synchronized 锁升级机制
地推
10-19 363
在 JDK 早期的版本，synchronized 锁的效率是非常低的，它的效率远低于 lock 锁，但是 sychronized 毕竟是 java 的关键词，它不应该就此淘汰。所以在 JDK1.6 中对它进行优化，其实优化内容不仅仅是与 synchronized 有关的，还有 "自适应自旋锁"、"锁消除"、"锁粗化" 等。这些优化和各种锁以及多线程的其他知识后面会开单独的一篇多线程的专栏来说。这里先简单的提一下，关于 synchronized 的优化就是它的升级机制。synchronized 也因为这个优化
Java多线程——线程优先级与守护线程（Daemon Thread）
Shenpotato的博客
08-03 337
一、线程优先级 每个线程都可以通过thread.setPriority()实现进程优先级的设置。可设置的范围在1-10之间，如果超过此范围将抛出异常throw new IllegalArgumentException()。每个线程的默认优先级为5。 tips：即使将某个线程的优先级高于另一个线程的优先级，并不意味着这个线程每次都能获得cpu资源，只是有比较大的可能性占用cpu资源。所以即使一个...
java线程同步synchronized
最新发布
07-27
Java中的线程同步是通过关键字synchronized来实现的。synchronized关键字可以应用在方法或代码块上，用于实现线程安全。当一个线程获取了某个对象的锁，其他试图获取该对象锁的线程将被阻塞，直到该线程释放锁。 在方法上使用synchronized关键字可以实现对整个方法的同步，即一次只能有一个线程执行该方法。示例代码如下： ```java public synchronized void synchronizedMethod() { // 线程安全操作 } ``` 在代码块上使用synchronized关键字可以实现对指定的代码块进行同步。示例代码如下： ```java public void synchronizedBlock() { synchronized (this) { // 线程安全操作 } } ``` 除了使用synchronized关键字外，还可以使用Lock接口的实现类，如ReentrantLock来实现线程同步。相比于synchronized关键字，Lock提供了更灵活的控制和更多的功能。 需要注意的是，在使用synchronized关键字时要注意锁的粒度，过大的锁粒度可能会影响程序的性能，而过小的锁粒度可能会导致线程安全问题。合理地使用线程同步机制可以有效地保证多线程环境下的数据一致性和安全性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值