并发编程---java锁

news2024/11/24 20:10:17

java锁

  • 一 多线程锁synchronized案例分析
    • 1.1synchronized介绍
    • 1.2 synchronized案例分析
      • 1.2.1.标准访问,请问先打印邮件还是短信?
      • 1.2.2.邮件⽅法暂停4秒钟,请问先打印邮件还是短信?
        • 分析
      • 1.2.3.新增⼀个普通⽅法hello(),请问先打印邮件还是hello?
      • 1.2.4.两部⼿机,请问先打印邮件还是短信?
      • 1.2.5.两个静态同步⽅法,同⼀部⼿机,请问先打印邮件还是短信?
      • 1.2.6.两个静态同步⽅法,2部⼿机,请问先打印邮件还是短信?
      • 1.2.7.1个普通同步⽅法,1个静态同步⽅法,1部⼿机,请问先打印邮件还是短信?
      • 1.2.8.1个普通同步⽅法,1个静态同步⽅法,2部⼿机,请问先打印邮件还有短信?
      • 1.2.8 总结
  • 二⼈⼯窗⼝排队购票(回顾)
  • 三 公平锁⾮公平锁 (⽕⻋站⼈⼯窗⼝排队购票)
  • 四 可重⼊锁/递归锁
    • 锁的配对
  • 五 ⾃旋锁
  • 六 读写锁/独占/共享

一 多线程锁synchronized案例分析

1.1synchronized介绍

关键字synchronized可以保证在同一时刻,只有一个线程可以执行某个方法或某个代码块,同时synchronized可以保证一个线程的变化可见(可见性),即可以代替volatile使用方法

1.普通同步方法(实例方法),锁是当前实例对象 ,进入同步代码前要获得当前实例的锁
2.静态同步方法,锁是当前类的class对象 ,进入同步代码前要获得当前类对象的锁
3.同步方法块,锁是括号里面的对象,对给定对象加锁,进入同步代码库前要获得给定对象的锁

1.2 synchronized案例分析

使用8个案例来详细说明synchronized的加锁用法:

1.标准访问,请问先打印邮件还是短信?
2.邮件⽅法暂停4秒钟,请问先打印邮件还是短信?
3.新增⼀个普通⽅法hello(),请问先打印邮件还是hello?
4.两部⼿机,请问先打印邮件还是短信?
5.两个静态同步⽅法,同⼀部⼿机,请问先打印邮件还是短信?
6.两个静态同步⽅法,2部⼿机,请问先打印邮件还是短信?
7.1个普通同步⽅法,1个静态同步⽅法,1部⼿机,请问先打印邮件还是短信?
8.1个普通同步⽅法,1个静态同步⽅法,2部⼿机,请问先打印邮件还有短信?

1.2.1.标准访问,请问先打印邮件还是短信?

答案:邮件

class Phone {
    public synchronized void sendEmail() {
        System.out.println("==========sendEmail");
    }
    public synchronized void sendMessage() {
        System.out.println("======sendMessage");
    }
}

public class LockDemo {
    public static void main(String[] args) {
        Phone phone = new Phone();

        new Thread(() -> {
            phone.sendEmail();
        }, "t1").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> {
            phone.sendMessage();
        }, "t2").start();
		//==========sendEmail
		//======sendMessage
    }
}

1.2.2.邮件⽅法暂停4秒钟,请问先打印邮件还是短信?

答案:邮件

//2. 邮件方法暂停4秒钟,请问先打印邮件还是短信? 邮件
class Phone {
    public synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("==========sendEmail");
    }
    public synchronized void sendMessage() {
        System.out.println("======sendMessage");
    }

}

public class LockDemo {
    public static void main(String[] args) {
        Phone phone = new Phone();

        new Thread(() -> {
            phone.sendEmail();
        }, "t1").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> {
            phone.sendMessage();
        }, "t2").start();
        //==========sendEmail
        //======sendMessage
    }
}

分析

普通同步方法(实例方法),锁是当前实例对象 ,进入同步代码前要获得当前实例的锁

⼀个对象⾥⾯如果有多个synchronized⽅法,某⼀个时刻内,只要⼀个线程去调⽤其中的⼀个synchronized⽅法了,其他的线程都只能等待。换句话说,某⼀个时刻内,只能有唯⼀⼀个线程去访问这些 synchronized⽅法,锁的是当前对象this(new 的这个phone),被锁定后,其他的线程都不能进⼊到当前对象的其他的synchronized⽅法。
在这里插入图片描述

1.2.3.新增⼀个普通⽅法hello(),请问先打印邮件还是hello?

答案:hello
加个普通⽅法后发现和同步锁⽆关
在这里插入图片描述

//3. 新增一个普通方法hello(),请问先打印邮件还是hello?
class Phone {
    public synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("==========sendEmail");
    }

    public synchronized void sendMessage() {
        System.out.println("======sendMessage");
    }

    public void hello() {
        System.out.println("sayHello");
    }
}

public class LockDemo {
    public static void main(String[] args) {
        Phone phone = new Phone();

        new Thread(() -> {
            phone.sendEmail();
        }, "t1").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> {
            phone.sendMessage();
        }, "t2").start();

        new Thread(() -> {
            phone.hello();
        }, "t3").start();
        //sayHello
        //==========sendEmail
        //======sendMessage
    }
}

1.2.4.两部⼿机,请问先打印邮件还是短信?

答案:邮件
分析:换成两个对象后,不是同⼀把锁了,情况⽴刻变化

//4. 两部手机,请问先打印邮件还是短信?
class Phone {
    public synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("==========sendEmail");
    }

    public synchronized void sendMessage() {
        System.out.println("======sendMessage");
    }

    public void hello() {
        System.out.println("sayHello");
    }
}

public class LockDemo {
    public static void main(String[] args) {
        Phone phone = new Phone();
        Phone phone2 = new Phone();

        new Thread(() -> {
            phone.sendEmail();
        }, "t1").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> {
            phone2.sendMessage();
        }, "t2").start();
        //======sendMessage
        //==========sendEmail
    }
}

1.2.5.两个静态同步⽅法,同⼀部⼿机,请问先打印邮件还是短信?

答案:邮件
分析:见 1.2.6

//5. 两个静态同步方法,同一部手机,请问先打印邮件还是短信?
class Phone {
    public static synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("==========sendEmail");
    }

    public static synchronized void sendMessage() {
        System.out.println("======sendMessage");
    }

    public void hello() {
        System.out.println("sayHello");
    }
}

public class LockDemo {
    public static void main(String[] args) {
        Phone phone = new Phone();

        new Thread(() -> {
            phone.sendEmail();
        }, "t1").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> {
            phone.sendMessage();
        }, "t2").start();
        //==========sendEmail
        //======sendMessage
    }
}

1.2.6.两个静态同步⽅法,2部⼿机,请问先打印邮件还是短信?

答案: 邮件
分析: 静态同步方法,锁是当前类的class对象 ,进入同步代码前要获得当前类对象的锁
全局锁
在这里插入图片描述

//6. 两个静态同步方法,2部手机,请问先打印邮件还是短信?
class Phone {
    public static synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("==========sendEmail");
    }

    public static synchronized void sendMessage() {
        System.out.println("======sendMessage");
    }

    public void hello() {
        System.out.println("sayHello");
    }
}

public class LockDemo {
    public static void main(String[] args) {
        Phone phone = new Phone();
        Phone phone2 = new Phone();
        new Thread(() -> {
            phone.sendEmail();
        }, "t1").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> {
            phone2.sendMessage();
        }, "t2").start();
        //==========sendEmail
        //======sendMessage
    }
}

1.2.7.1个普通同步⽅法,1个静态同步⽅法,1部⼿机,请问先打印邮件还是短信?

答案: 短信
分析:
在这里插入图片描述

//7. 1个普通同步方法,1个静态同步方法,1部手机,请问先打印邮件还是短信?
class Phone {
    public  synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("==========sendEmail");
    }

    public static synchronized void sendMessage() {
        System.out.println("======sendMessage");
    }

    public void hello() {
        System.out.println("sayHello");
    }
}

public class LockDemo {
    public static void main(String[] args) {
        Phone phone = new Phone();

        new Thread(() -> {
            phone.sendEmail();
        }, "t1").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> {
            phone.sendMessage();
        }, "t2").start();
        //======sendMessage
        //==========sendEmail
    }
}

1.2.8.1个普通同步⽅法,1个静态同步⽅法,2部⼿机,请问先打印邮件还有短信?

答案: 短信
分析:

在这里插入图片描述

1.2.8 总结

(1)当⼀个线程试图访问同步代码块时,它⾸先必须得到锁,退出或抛出异常时必须释放锁。 也就是说如果⼀个实例对象的普通同步⽅法获取锁后,该实例对象的其他普通同步⽅法必须等待获取锁的⽅法释放锁后才能获取锁,可是别的实例对象的普通同步⽅法因为跟该实例对象的普通同步⽅法⽤的是不同的锁,所以⽆需等待该实例对象已获取锁的普通同步⽅法释放锁就可以获取他们⾃⼰的锁。
(2)所有的静态同步⽅法⽤的也是同⼀把锁–类对象本身, 这两把锁(this/class)是两个不同的对象,所以静态同步⽅法与⾮静态同步⽅法之间是 不会有静态条件的。 但是⼀旦⼀个静态同步⽅法获取锁后,其他的静态同步⽅法都必须等待该⽅法释放锁后才能获取锁,⽽不管是同⼀个实例对象的静态同步⽅法之间,还是不同的实例对象的静态同步⽅法之间,只要它们同⼀个类的实例对象

二⼈⼯窗⼝排队购票(回顾)

题目:三个售票员 卖出 30张票
多个线程共抢一个资源

/**
 * 题目:三个售票员   卖出   30张票
 *
 */
class Ticket{//资源类
    //票
    private int number = 30;
    
    public synchronized void saleTicket(){
        if (number > 0) {
            System.out.println(Thread.currentThread().getName()+"\t卖出第:"+(number--)+"\t还剩下:"+number);
        }
    }
 }
 public class SaleTicketDemo {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();

        new Thread(()->{ for (int i = 1; i <= 30 ; i++) ticket.saleTicket(); }, "A").start();
        new Thread(()->{ for (int i = 1; i <= 30 ; i++) ticket.saleTicket(); }, "B").start();
        new Thread(()->{ for (int i = 1; i <= 30 ; i++) ticket.saleTicket(); }, "C").start();
    }
}

在这里插入图片描述
我们用synchronized同步代码块的方式来解决。随着juc并发编程。我们有更加轻量级的锁方式来解决问题。

三 公平锁⾮公平锁 (⽕⻋站⼈⼯窗⼝排队购票)

lcok锁

 Lock lock = new ReentrantLock();

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
概念
公平锁,就是多个线程按照申请锁的顺序来获取锁,类似排队,先到先得。
⾮公平锁,则是多个线程抢夺锁,会导致优先级反转或饥饿现象。
区别:

  • 公平锁在获取锁时先查看此锁维护的等待队列,为空或者当前线程是等待队列的队⾸,则直接占有锁,否则插⼊到等待队列,FIFO原则。
  • ⾮公平锁⽐较粗鲁,上来直接先尝试占有锁,失败则采⽤公平锁⽅式。⾮公平锁的优点是吞吐量⽐公平锁更⼤。

synchronizedjuc.ReentrantLock默认都是⾮公平锁ReentrantLock在构造的时候传⼊ true 则是公平锁

四 可重⼊锁/递归锁

在这里插入图片描述
可重⼊锁⼜叫递归锁指的同⼀个线程在外层⽅法获得锁时,进⼊内层⽅法会⾃动获取锁。也就是说,线程可以进⼊任何⼀个它已经拥有锁的代码块。
⽐如method01⽅法⾥⾯有method02⽅法,两个⽅法都有同⼀把锁,得到了method01的锁。就⾃动得到了method02的锁,就像有了家⻔的锁,厕所、书房、厨房就为你敞开了⼀样。可重⼊锁可以避免死锁的问题。
在这里插入图片描述


/**
 * 可重入锁/递归锁
 */

class PhonePlus implements Runnable{

    //Synchronized Test
    public synchronized void sendEmail(){
        System.out.println(Thread.currentThread().getName()+"\t"+"sendEmail");
        sendSMS();
    }

    public synchronized void sendSMS(){
        System.out.println(Thread.currentThread().getName()+"\t"+"sendSMS");
    }

    //ReenTrantLock Test
    Lock lock = new ReentrantLock();
    public void method1(){
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName()+"\t"+"method1");
            method2();
        } finally {
            lock.unlock();
        }
    }

    public void method2() {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName()+"\t"+"method2");
        } finally {
            lock.unlock();
        }
    }

    @Override
    public void run() {
        method1();
    }
}

public class ReentrantLockDemo {
    public static void main(String[] args) {
        PhonePlus phonePlus = new PhonePlus();

        new Thread(()->{
            phonePlus.sendEmail();
        }, "t1").start();

        new Thread(()->{
            phonePlus.sendEmail();
        }, "t2").start();

        Thread t3 = new Thread(phonePlus);
        Thread t4 = new Thread(phonePlus);
        t3.start();
        t4.start();
    }
}


锁的配对

锁之间要配对,加了⼏把锁,最后就得解开⼏把锁,下⾯的代码编译和运⾏都没有任何问题。但锁的数量不匹配会导致死循环。

lock.lock();
lock.lock();
try{
	someAction(); 
}finally{
	lock.unlock(); 
}

五 ⾃旋锁

所谓⾃旋锁,就是尝试获取锁的线程不会⽴即阻塞,⽽是采⽤循环的⽅式去尝试获取。⾃⼰在那⼉⼀直循环获取,就像“⾃旋”⼀样。这样的好处是减少线程切换的上下⽂开销,缺点是会消耗CPU。CAS底层的 getAndAddInt就是⾃旋锁思想。

//跟CAS类似,⼀直循环⽐较。
while (!atomicReference.compareAndSet(null, thread)) { }

在这里插入图片描述

/**
 * 题目:实现一个自旋锁
 * 自旋锁好处:循环比较获取直到成功为止,没有类似wait的阻塞。
 * <p>
 * 通过CAS操作完成自旋锁,A线程先进来调用myLock方法自己持有锁5秒钟,
 * B随后进来后发现当前有线程持有锁,不是null,所以只能通过自选等待,直到A释放锁后B随后抢到。
 */
public class SpinLockDemo {

    //原子引用(线程)
    AtomicReference<Thread> atomicReference = new AtomicReference<>(); //Thread ==> null

    //获取锁
    public void myLock() {
        Thread currentThread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName() + "\t com in...");

        while (!atomicReference.compareAndSet(null, currentThread)) {
        }
    }

    //释放锁
    public void myUnLock() {
        Thread currentThread = Thread.currentThread();
        atomicReference.compareAndSet(currentThread, null);
        System.out.println(Thread.currentThread().getName() + "\t unlock....");
    }

    public static void main(String[] args) {
        SpinLockDemo spinLockDemo = new SpinLockDemo();

        new Thread(() -> {
            spinLockDemo.myLock();
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            spinLockDemo.myUnLock();
        }, "AA").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            spinLockDemo.myLock();
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            spinLockDemo.myUnLock();
        }, "BB").start();
    }
}

结果
在这里插入图片描述
过程分析
在这里插入图片描述

六 读写锁/独占/共享

读锁是共享的,写锁是独占的。 juc.ReentrantLocksynchronized都是独占锁,独占锁就是⼀个锁只能被⼀个线程所持有。有的时候,需要读写分离,那么就要引⼊读写锁,即 juc.ReentrantReadWriteLock

独占锁:指该锁⼀次只能被⼀个线程所持有。对ReentrantLockSynchronized⽽⾔都是独占锁
共享锁:指该锁可被多个线程所持有
ReenntrantReadWriteLock其读锁是共享锁,其写锁是独占锁。
读锁的共享锁可保证并发读是⾮常⾼效的,读写、写读、写写的过程是互斥的。

⽐如缓存,就需要读写锁来控制。缓存就是⼀个键值对,以下Demo模拟了缓存的读写操作,读的 get ⽅法使⽤了 ReentrantReadWriteLock.ReadLock(),写的 put⽅法使⽤了ReentrantReadWriteLock.WriteLock()。这样避免了写被打断,实现了多个线程同时读。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/401602.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

Django系统开发

Django系统开发 1.新建项目 创建Django项目 删除templates目录 删除settings.py里templates -> DIRS的列表数据 2.创建app 在Pycharm中 注册app 在settings.py中找到 INSTALLED_APPS 加入对应路径 app01.apps.App01Config 3.表结构 from django.db import modelsclas…

32位处理器AM6528BACDXEA、AM6548BACDXEAF基于Arm Cortex-A53内核【工业4.0嵌入式产品应用】

AM6528BACDXEA、AM6548BACDXEAF 处理器是专为满足工业4.0嵌入式产品对处理性能的复杂需求而设计的Arm应用处理器。AM654x和AM652x器件将四个或两个Arm Cortex-A53内核与一个双Arm Cortex-R5F MCU子系统结合在一起。这些包含的功能旨在帮助客户实现终端产品的功能安全目标。它还…

绘制CSP的patterns矩阵图

最近在使用FBCSP处理数据,然后就想着看看处理后的样子,用地形图的形式表现出来,但是没有符合自己需求的函数可以实现,就自己尝试的实现了一下,这里记录一下,方便以后查阅。 绘制CSP的patterns矩阵图 对数据做了FBCSP处理,但是想画一下CSP计算出来的patterns的地形图,并…

成功的项目管理策略:减少成本,提高质量

项目管理是一项具有挑战性的任务&#xff0c;项目团队需要合理的规划和策略&#xff0c;以确保项目的成功和达成预期。为了实现项目的成功&#xff0c;项目经理必须采用正确的策略&#xff0c;才能以最大限度地减少成本并提高项目质量。本文将探讨成功的项目管理策略&#xff0…

Django实践-05Cookie和Session

文章目录Django实践-05Cookie和SessionDjango实践-05Cookie和Session用户登录的准备工作1. 创建用户模型。2. 正向工程生成数据库表3.写utils.py文件&#xff0c;密码转md54.给数据表tb_user中插入测试数据5.编写用户登录的视图函数和模板页。6.编写urls.py。6.增加login.html模…

数据仓库相关概念的解释

数据仓库相关概念的解释 文章目录数据仓库相关概念的解释1 ETL是什么&#xff1f;ETL体系结构2 数据流向何为数仓DW3 ODS 是什么&#xff1f;4 数据仓库层DWDWD 明细层DWD 轻度汇总层&#xff08;MID或DWB&#xff0c;data warehouse basis&#xff09;DWS 主题层&#xff08;D…

MySQL8读写分离集群

文章目录前言MySQL读写分离原理搭建MySQL读写分离集群MySQL8.0之前MySQL8.0之后后记前言 上一期介绍并实现了MySQL的主从复制&#xff0c;由于主从复制架构仅仅能解决数据冗余备份的问题&#xff0c;从节点不对外提供服务&#xff0c;依然存在单节点的高并发问题 所以在主从复…

【Vue】10分钟带你读懂Vue的过滤器

一、什么是过滤器&#xff1f;过滤器提供给我们的一种数据处理方式。过滤器功能不是必须要使用的&#xff0c;因为它所实现的功能也能用计算属性或者函数调用的方式来实现。Vue.js 允许你自定义过滤器&#xff0c;可被用于一些常见的文本格式化。二、过滤器声明与使用过滤器应该…

重构SeleniumeDownloader底层浏览器驱动

一、解决bug&#xff1a;Selenium with PhantomJS&#xff0c;重构SeleniumeDownloader底层浏览器驱动 0、小背景&#xff1a; 想爬取外网steam的数据&#xff0c;但是steam官网在海外&#xff0c;加上steam处于反爬考虑&#xff0c;对于异步数据-json数据进行处理&#xff0…

三天吃透RabbitMQ面试八股文

本文已经收录到Github仓库&#xff0c;该仓库包含计算机基础、Java基础、多线程、JVM、数据库、Redis、Spring、Mybatis、SpringMVC、SpringBoot、分布式、微服务、设计模式、架构、校招社招分享等核心知识点&#xff0c;欢迎star~ Github地址&#xff1a;https://github.com/…

51驱动NRF24L01通信,NRF24L01与TTL转NRF24L01模块通信

51驱动NRF24L01通信&#xff0c;NRF24L01与TTL转NRF24L01模块通信NRF24L01一、简介二、引脚功能描述程序设计一、对 24L01 的程序编程的基本思路如下&#xff1a;二、Tx 与 Rx 的配置过程1、Tx 模式初始化过程&#xff1a;2、Rx 模式初始化过程&#xff1a;三、基本程序函数通信…

五分钟了解支付、交易、清算、银行等专业名词的含义?

五分钟了解支付、交易、清算、银行等专业名词的含义&#xff1f;1. 支付类名词01 支付应用02 支付场景03 交易类型04 支付类型&#xff08;按通道类型&#xff09;05 支付类型&#xff08;按业务双方类型&#xff09;06 支付方式07 支付产品08 收银台类型09 支付通道10 通道类型…

LeetCode-416. 分割等和子集

目录题目分析回溯法动态规划动态规划(压缩)题目来源 416. 分割等和子集 题目分析 这道题目是要找是否可以将这个数组分割成两个子集&#xff0c;使得两个子集的元素和相等。 那么只要找到集合里能够出现 sum / 2 的子集总和&#xff0c;就算是可以分割成两个相同元素和子集了…

使用 ONLYOFFICE 宏借助 ChatGPT 生成文章

AI 技术在过去几年中得到了显著提升&#xff0c;同时也成为了我们日常生活中必不可少的一部分。现在&#xff0c;我们会将这种高科技功能纳入到文档撰写过程。在本文中&#xff0c;我们将展示如何构建一个宏来使用 ChatGPT API 生成文章。 关于 ChatGPT ChatGPT 是由 OpenAI 开…

html2canvas和jspdf导出pdf,每个页面模块占一页,在pdf中垂直居中显示

需求&#xff1a;html页面转换pdf&#xff0c;页面有多个模块&#xff0c;页面中有文本、echarts、表格等模块&#xff0c;一个模块占一页&#xff0c;因为模块高度不够&#xff0c;所以需要垂直居中 通过html2canvas和jspdf实现&#xff0c;html2canvas用于将页面元素生成canv…

以java编写员工管理系统(测试过 无问题)

一、系统结果的部分展示 二、题目以及相关要求 三、组成 1.该系统由 Employee 类 、commonEmployee类、Testemd类和managerEmployee类组成 2.Employee实现的代码 public class Employee {private String id;private String name;private String job;private int holiday…

弱监督参考图像分割:Learning From Box Annotations for Referring Image Segmentation论文阅读笔记

弱监督参考图像分割&#xff1a;Learning From Box Annotations for Referring Image Segmentation论文阅读笔记一、Abstract二、引言三、相关工作A、全监督参考图像分割B、基于 Box 的实例分割C、带有噪声标签的学习四、提出的方法A、概述B、伪标签生成目标轮廓预测Proposal 选…

exe打包工具:advanced installer介绍(一)

前言近年来&#xff0c;web服务逐渐走向云端部署浏览器化、去APP化&#xff0c;然而exe安装仍有着举足轻重的地位&#xff0c;其好处不言而喻&#xff0c;拿到exe安装包后&#xff0c;基本就可以傻瓜安装和操作了&#xff0c;十分便捷。业务场景通过各种IDE/QT/C#/Java等开发工…

项目的生命周期与成本、风险、变更的关系

成本与人力投入水平 项目成本的投入在初始阶段逐渐增加&#xff0c;在执行的中间阶段达到顶峰&#xff0c;在项目收尾阶段逐渐下降。成本的投入趋势如下图所示&#xff1a; 初始阶段&#xff1a;从人力成本来看&#xff0c;信息系统开发团队在前期制定项目管理章程及项目管理…

PCB焊盘设计基本原则

SMT的组装质量与PCB焊盘设计有直接的关系&#xff0c;焊盘的大小比例十分重要。如果PCB焊盘设计正确&#xff0c;贴装时少量的歪斜可以再次回流焊纠正(称为自定位或自校正效应)&#xff0c;相反&#xff0c;如果PCB焊盘设计不正确&#xff0c;即使贴装位置十分准确&#xff0c;…