【JavaEE初阶系列】——一万字带你了解 JUC常见类 以及 线程安全集合类(哈希表)

目录

🚩JUC(java.util.concurrent) 的常见类

🎈Callable 接口

🌈理解 Callable(相关面试题)

🌈理解 FutureTask 

📝线程创建方式

🎈 ReentrantLock可重入锁

🌈ReentrantLock 优势:

🌈ReentrantLock和synchronized区别:

🎈原子类

🎈信号量 Semaphore

🌈信号量代码示例

🎈CountDownLatch任务进度

🎈相关面试题

🚩线程安全的集合类  

🎈多线程环境使用 ArrayList

🎈多线程环境使用哈希表


🚩JUC(java.util.concurrent) 的常见类


🎈Callable 接口

Callable 是一个 interface . 相当于把线程封装了一个 " 返回值 ". 方便程序猿借助多线程的方式计算结果。Runnable不在意结果,而Callable接口,创建线程,可直接返回结果。
代码示例: 创建线程计算 1 + 2 + 3 + ... + 1000, 不使用 Callable 版本
  • 创建一个类 Result , 包含一个 sum 表示最终结果, lock 表示线程同步使用的锁对象.
  • main 方法中先创建 Result 实例, 然后创建一个线程 t. 在线程内部计算 1 + 2 + 3 + ... + 1000.
  • 主线程同时使用 wait 等待线程 t 计算结束. (注意, 如果执行到 wait 之前, 线程 t 已经计算完了, 就不必等待了).
  • 当线程 t 计算完毕后, 通过 notify 唤醒主线程, 主线程再打印结果
//实现1+2+3.。。+1000
class Result{public  int sum;//创建public Object lock=new Object();
}
public class Test2 {public static void main(String[] args) throws InterruptedException {Result result=new Result();//创建对象实例Thread thread=new Thread(new Runnable() {@Overridepublic void run() {int sum=0;for (int i = 1; i <=1000 ; i++) {sum+=i;}synchronized (result.lock){result.sum=sum;//将结果赋值给result类中sumresult.lock.notify();//然后唤醒}}});thread.start();synchronized (result.lock){while (result.sum==0){result.lock.wait();//如果sum里的值一直是0,那么就一直等待}System.out.println(result.sum);//之后唤醒之后,就打印sum的值。}}
}
可以看到 , 上述代码需要一个辅助类 Result, 还需要使用一系列的加锁和 wait notify 操作 , 代码复
, 容易出错
代码示例: 创建线程计算 1 + 2 + 3 + ... + 1000, 使用 Callable 版本
  • 创建一个匿名内部类, 实现 Callable 接口. Callable 带有泛型参数. 泛型参数表示返回值的类型.
  • 重写 Callable 的 call 方法, 完成累加的过程. 直接通过返回值返回计算结果.
  • callable 实例使用 FutureTask 包装一下.
  • 创建线程, 线程的构造方法传入 FutureTask . 此时新线程就会执行 FutureTask 内部的 Callable call 方法, 完成计算. 计算结果就放到了 FutureTask 对象中.
  • 在主线程中调用 futureTask.get() 能够阻塞等待新线程计算完毕. 并获取到 FutureTask 中的结.
package Java_improvr;import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;public class Callable_test2 {public static void main(String[] args) throws ExecutionException, InterruptedException {Callable<Integer>callable=new Callable<Integer>() {@Overridepublic Integer call() throws Exception {int sum=0;for (int i = 1; i <=1000 ; i++) {sum+=i;}return sum;}};//将任务放进到线程中FutureTask<Integer>futureTask=new FutureTask<>(callable);Thread thread=new Thread(futureTask);thread.start();System.out.println(futureTask.get());
此处的get就能获取到Callable里面的返回结果,由于线程是并发执行的,
执行到主线程的get的时候,t线程可能还没执行完,没执行完的话,get就会阻塞。}
}

可以看到, 使用 Callable 和 FutureTask 之后, 代码简化了很多, 也不必手动写线程同步代码了 


🌈理解 Callable(相关面试题)

  • Callable 和 Runnable 相对, 都是描述一个 "任务". Callable 描述的是带有返回值的任务,Runnable 描述的是不带返回值的任务。
  • Callable 通常需要搭配 FutureTask 来使用. FutureTask 用来保存 Callable 的返回结果. 因为 Callable 往往是在另一个线程中执行的, 啥时候执行完并不确定.
FutureTask 就可以负责这个等待结果出来的工作.FutureTask对象就是放在线程中等待线程执行完后,调用get方法就得到了返回值。

🌈理解 FutureTask 

想象去吃麻辣烫. 当餐点好后, 后厨就开始做了. 同时前台会给你一张 "小票" . 这个小票就是
FutureTask. 后面我们可以随时凭这张小票去查看自己的这份麻辣烫做出来了没.做出来了get方法调用成功然后菜就出来了,如果没做出了,get方法就等待线程完成,直到出来后,就返回值。

📝线程创建方式

  1. 继承Thread,重写run(创建单独的类,也可以匿名内部类)
  2. 实现Runnable,重写run(创建单独的类,也可以匿名内部类)
  3. 实现Callable,重写call(创建单独的类,也可以匿名内部类)
  4. 实现lambda表达式
  5. ThreadFactory线程工厂
  6. 线程池

🎈 ReentrantLock可重入锁

可重入互斥锁. synchronized 定位类似, 都是用来实现互斥效果, 保证线程安全.

ReentrantLock 也是可重入锁. "Reentrant" 这个单词的原意就是 "可重入"
ReentrantLock 的用法:
  • lock(): 加锁, 如果获取不到锁就死等.
  • trylock(超时时间): 加锁, 如果获取不到锁, 等待一定的时间之后就放弃加锁.
  • unlock(): 解锁
ReentrantLock lock = new ReentrantLock(); 
-----------------------------------------
lock.lock();   
try {    // working    
} finally {    lock.unlock()    
}

我们之前学到try()..catch()..,如果加上finally的话,finally是肯定会被调用的,一般用于释放或者释放锁的作用,所以finally的话是肯定会执行到的代码。

🌈ReentrantLock 优势:

  • ReentrantLock,在加锁的时候,有俩种方式,lock,trylock
  • ReentrantLock提供了公平锁的实现(默认情况下是非公平锁)
  • ReentrantLock提供了更强大的等待通知机制,搭配了Condition类,实现等待通知的。

虽然ReentrantLock有上述的优势,但是咱们在加锁的时候,还是首选synchronized(而且synchronized背后还有一系列的优化手段,锁升级,锁粗化,锁消除),ReentrantLock使用更加的复杂,尤其是容易忘记解锁。

🌈ReentrantLock和synchronized区别:

  • 库的一个类, JVM 外实现的(基于 Java 实现). synchronized 使用时不需要手动释放锁. ReentrantLock 使用时需要手动释放. 使用起来更灵活, 但是也容易遗漏 unlock.
  • synchronized 在申请锁失败时, 会死等. ReentrantLock 可以通过 trylock 的方式等待一段时间就 放弃.(trylock没有加锁就直接放弃,给了更多可操作的空间,放弃申请锁之后就可以做其他的事情。)
  • synchronized 是非公平锁, ReentrantLock 默认是非公平锁. 可以通过构造方法传入一个 true 开启公平锁模式。
// ReentrantLock 的构造方法
public ReentrantLock(boolean fair) {sync = fair ? new FairSync() : new NonfairSync();
}
  • 更强大的唤醒机制. synchronized 是通过 Object wait / notify 实现等待-唤醒. 每次唤醒的是一 个随机等待的线程. ReentrantLock 搭配 Condition 类实现等待-唤醒, 可以更精确控制唤醒某个指定的线程.(在多线程中等待的情况下,synchronized唤醒的是随机等待的线程,而ReentrantLock则唤醒的是指定的线程)。

如何选择使用哪个锁?
  • 锁竞争不激烈的时候, 使用 synchronized, 效率更高, 自动释放更方便.
  • 锁竞争激烈的时候, 使用 ReentrantLock, 搭配 trylock 更灵活控制加锁的行为, 而不是死等.
  • 如果需要使用公平锁, 使用 ReentrantLock.

🎈原子类

在Java中,在java.util.Atomic包下有个,原子类(Atomic classes)是一组类,用于在多线程环境中进行原子操作。原子操作是不可分割的操作,可以看作是一组指令的执行过程中不会被中断的操作。原子类提供了一种线程安全的方式来执行诸如读取、写入和更新变量等操作,而无需显式地使用锁或同步块来保护数据。

Java中的原子类位于java.util.concurrent.atomic包中,主要有以下几个常见的原子类:

  1. AtomicBoolean: 提供了对boolean类型变量的原子操作。
  2. AtomicInteger: 提供了对int类型变量的原子操作。
  3. AtomicLong: 提供了对long类型变量的原子操作。
  4. AtomicReference: 提供了对引用类型变量的原子操作。
  5. AtomicIntegerArray: 提供了对int类型数组的原子操作。
  6. AtomicLongArray: 提供了对long类型数组的原子操作。
  7. AtomicReferenceArray: 提供了对引用类型数组的原子操作。

这些原子类通过使用底层的CAS(Compare-And-Swap)操作来实现原子性。CAS是一种乐观锁的机制,它在操作之前先比较内存中的值是否与预期值相等,如果相等,则执行操作,否则放弃操作。CAS操作是一种非阻塞算法,因此在高并发情况下性能通常比传统的基于锁的同步方式更好。


  AtomicInteger类举例,常见方法 

public class Test5 {public static AtomicInteger count=new AtomicInteger(0);//对int类型封装public static void main(String[] args) {count.addAndGet(1); //0+1=1         i+=deltaSystem.out.println(count);count.decrementAndGet(); //--1=0 count=0  --iSystem.out.println(count);count.getAndIncrement(); //0++=0 count=1  i++System.out.println(count);count.incrementAndGet(); //++1=2          ++iSystem.out.println(count);count.getAndDecrement(); //2--=2 count=1  i--System.out.println(count);}
}
  • addAndGet(int delta);   i += delta;
  • decrementAndGet(); --i;
  • getAndDecrement(); i--;
  • incrementAndGet(); ++i;
  • getAndIncrement(); i++;

在多线程情况下,进行i++操作。这样就避免了 加锁,底层用的是CAS。 

package Java_improvr;import java.util.concurrent.atomic.AtomicInteger;public class Test1 {public static AtomicInteger count=new AtomicInteger(0);//对int类型封装public static void main(String[] args) throws InterruptedException {Thread t1=new Thread(()->{for (int i = 0; i < 50000; i++) {count.getAndIncrement();}});Thread t2=new Thread(()->{for (int i = 0; i < 50000; i++) {count.getAndIncrement();}});t1.start();t2.start();t1.join();t2.join();System.out.println(count.get());}
}

🎈信号量 Semaphore

信号量 , 用来表示 "可用资源的个数". 本质上就是一个计数器 .
理解信号量
可以把信号量想象成是停车场的展示牌,当前有车位100个,表示有100个可用资源。
  • 当有车开进去的时候,就相当于申请一个可用资源,可用车位就-1 (这个称为信号量的P操作)
  • 当有车开出去的时候,就相当于释放一个可用资源,可用车位就+1  (这个称为信号量的V操作
如果计数器的值已经为0了,还尝试申请资源,就会阻塞等待,直到有其他线程释放资源。
public class Test6 {public static void main(String[] args) throws InterruptedException {Semaphore semaphore=new Semaphore(4);//申请了4个资源semaphore.acquire();System.out.println("P操作");semaphore.acquire();System.out.println("P操作");semaphore.acquire();System.out.println("P操作");semaphore.acquire();System.out.println("P操作");semaphore.acquire();System.out.println("P操作");}
}

这样我们就会让我们想到锁。

锁就是可用资源为1的信号量。(二元信号量)
  • 加锁操作,P操作,1->0
  • 解锁操作,V操作,0->1
操作系统,提供了信号量实现,提供了api,JVM封装了这样的api,就可以在java代码中使用了。

🌈信号量代码示例

  • 创建 Semaphore 示例, 初始化为 4, 表示有 4 个可用资源.
  • acquire 方法表示申请资源(P操作), release 方法表示释放资源(V操作)
  • 创建 20 个线程, 每个线程都尝试申请资源, sleep 1秒之后, 释放资源. 观察程序的执行效果
package Java_improvr;import java.util.concurrent.Semaphore;public class Test6 {public static void main(String[] args) {Semaphore semaphore=new Semaphore(4);//申请了4个资源Runnable runnable=new Runnable() {@Overridepublic void run() {try {System.out.println("申请资源");semaphore.acquire();System.out.println("我获取到了资源");Thread.sleep(1000);System.out.println("我释放了资源");semaphore.release();}catch (InterruptedException e){e.printStackTrace();}}};for (int i = 0; i <20 ; i++) {Thread t=new Thread(runnable);t.start();}}
}

🎈CountDownLatch任务进度

同时等待 N 个任务执行。适用于,多个线程来完成一系列任务的时候,用来衡量任务的进度是否完成,比如需要把一个大的任务,拆分成多个小的任务,让这些任务并发的去执行。
就可以 使用countDownLatch来判定说当前这些任务是否全都完成了。
比如说下载一个文件,就可以使用多线程下载。很多下载工具,下载速度,很一般,相比之下,有些专业的下载工具,就可以成倍的提升下载速度(IDM),多线程下载,(往往和资源服务器只有一个连接,服务器往往会对于连接传输的速度有限制),每个线程都建立一个连接,此时就需要把任务进行分割。
countDownLatch主要有俩个方法:
  • 1.await,调用的时候就会阻塞,就会等待其他的线程完成任务,所有的线程都完成了任务之后,此时这个await才会返回,才会继续往下走。
  • 2.countDown,告诉countDownatch,我当前这一个子任务已经完成了。

await代表所有任务完成,countDown代表分割成的小任务完成。

public class Test7 {public static void main(String[] args) throws InterruptedException {//10个选手参赛,await就会在10次调用完countDown之后才能继续执行CountDownLatch latch=new CountDownLatch(10);for (int i = 0; i < 10; i++) {int id=i;Thread t=new Thread(()->{System.out.println("thread"+id);latch.countDown();//代表一个小任务完成});t.start();}latch.await();//代表所有任务都完成System.out.println("await调用了代表所有任务都完成了");}
}

每个任务完成得顺序是随机得,就像10个选手参赛,选手就是线程,每个人得成绩都是不一样得,有先后区分。等到所有得选手都参赛完了后,就调用await方法。


🎈相关面试题

1) 线程同步的方式有哪些?
synchronized(锁), ReentrantLock(可重入锁), Semaphore(信号量) 等都可以用于线程同步.
2) 为什么有了 synchronized 还需要 juc 下的 lock?
以 juc 的 ReentrantLock 为例,
  • synchronized不用手动得释放锁,而ReentranLock需要手动得调用unlock释放锁,容易忽略。
  • synchronized申请锁失败后,就会死等,而ReentranLock可以通过trylock方式等待一段时间就会自动放弃。
  • synchronized是非公平锁,ReentranLock默认是非公平锁,可以通过构造方法传入一个true开启公平锁模式
  • synchronized搭配得wait/notify实现等待-唤醒线程,每次唤醒的是一个随机等待的线程。ReentranLock搭配的Condition类实现等待-唤醒,可以更精准控制唤醒某个指定的线程。
3) AtomicInteger 的实现原理是什么?
基于 CAS 机制. 伪代码如下
class AtomicInteger {
private int value;
public int getAndIncrement() {int oldValue = value;while ( CAS(value, oldValue, oldValue+1) != true) {oldValue = value;}return oldValue;}
}
4) 信号量听说过么?之前都用在过哪些场景下?
信号量"用来表示资源的个数",本质上是个计数器。
使用信号量可以实现"共享锁",比如某个资源允许3个线程同时使用,那么就可以使用P操作作为加锁,V操作作为解锁,前三个线程的P操作都能顺序返回,后续线程再进行P操作就会阻塞等待,直到前面的线程执行了V操作。

🚩线程安全的集合类  

原来的集合类 , 大部分都不是线程安全的 .
Vector, Stack, HashTable, 是线程安全的(不建议用), 其他的集合类不是线程安全的.
针对这些线程不安全的集合类,要想在多线程环境下使用,就需要考虑好,线程安全问题了。

🎈多线程环境使用 ArrayList

1) Collections.synchronizedList(new ArrayList);
synchronizedList 是标准库提供的一个基于 synchronized 进行线程同步的 List.
synchronizedList 的关键操作上都带有 synchronized.
这个操作会返回新的对象,这个新的对象就相当于给ArrayList套了一层壳,这层壳就是在方法上直接使用synchronized的。
2) 使用 CopyOnWriteArrayList
写时拷贝,比如俩个线程使用同一个ArrayList,可能会读,也可能会修改。
如果要是俩个线程读,就直接读就好了,
如果某个线程需要修改,就把ArrayList复制出一份副本,就修改这个副本,与此同时,另一个线程仍然可以读取数据(从原来的数据上进行读取)一旦这边修改完毕,就会使用修改好的这份数据,替代掉原来的数据(往往就是一个引用赋值)
CopyOnWrite容器即写时复制的容器
  • 当我们往一个容器添加元素的时候,不直接往当前容器添加,而是先将当前容器进行Copy, 复制出一个新的容器,然后新的容器里添加元素,
  • 添加完元素之后,再将原容器的引用指向新的容器
这样做的好处是我们可以对CopyOnWrite容器进行并发的读,而不需要加锁,因为当前容器不会添加任何元素。
所以CopyOnWrite容器也是一种读写分离的思想,读和写不同的容器。
  • 优点:

在读多写少的场景下, 性能很高, 不需要加锁竞争.

  • 缺点:

1. 占用内存较多.

2. 新写的数据不能被第一时间读取到.

其实这种场景特别适合于 服务器的配置更新,可以通过配置文件,来描述配置的详细内容(本身就不会很大)配置的内容会被读到内存中,再由其他线程,读取到这里的内容,但是修改这个配置内容,往往只有一个线程去修改,使用某个命令让服务器重新加载配置,就可以使用写时拷贝的方式了。

🎈多线程环境使用哈希表

HashMap 本身不是线程安全的 .
在多线程环境下使用哈希表可以使用 :
  • Hashtable
  • ConcurrentHashMap
Hashtable保证线程安全,主要就是给关键方法,加上synchronized,直接加到方法上的 (相当于给this加锁),只要俩个线程,在操作同一个Hashtable就会出现锁冲突。
俩个不同key映射到同一个数组下标上,就会出现hash冲突,使用链表来解决hash冲突。
按照上述这样的方式来操作,并且在不考虑 触发扩容 的前提下,操作不同的链表的时候就是线程安全的,相比之下,如果俩个线程,操作的是同一个链表,才比较会出现问题。(就像之前说的,多线程对同一个变量进行修改,会出现线程安全问题)。
1》ConcurrentHashMap最核心的改进,就是把一个大局的大锁,改进成 每个链表独立的一把小锁,这样做,大幅度的降低了锁冲突的概率。    大锁-》小锁
如果一个大锁 ,当很多线程进行插入到哈希表的时候,此时每个线程都得等待前一个线程进入并且插入完成后,然后下一个线程进入,这就是造成了阻塞等待的状况。                              其实一个hash表中有很多这样的链表,俩个线程恰好同时访问同一个链表的情况,本身就很少。所以我们就想到                                                                                                                              

   将一个大局的大锁,改进成每个链表独立的一把小锁,锁对象就是链表的头结点。 遇到访问不同的链表的时候,是不产生锁冲突的,遇到访问同一个链表,会阻塞等待,但是比大锁更高效,因为这样其他所有的线程都被阻塞了,而小锁会避免不必要的锁冲突。            
分段锁:java8之前 ConcurrentHashMap就是基于分段锁(多个链表公用一把锁)的方式实现的。等到java8开始之后,就成了直接在链表头结点加锁的形式。

2》充分利用到了CAS特性,把一些不必要的加锁环节省略加锁了

    比如:需要使用变量记录hash表中的元素个数,此时 ,就可以使用原子操作(CAS) 修改元素个数。

3》ConcurrentHashMap还有一些激进的操作,针对读操作没有加锁。读和读之间,读和写之间,都不会有锁竞争。

写和写之间还是要加锁的。

4》ConcurrentHashMap 针对扩容操作,做出了单独的优化

本身Hashtable或者HashMap 在扩容的时候,都是需要把所有的元素都拷贝一遍的(如果元素很多,拷贝的就比较耗时)

用户访问100次,99次都很流畅,其中一次卡了(正好触发了扩容的机制,导致了出现卡顿)

化整为零。一旦需要扩容,确实需要搬运,不是在一次操作中搬运完成,而是分成多次来搬运,每次只搬运一部分数据,避免这单次操作过去卡顿。


我时常消极 又觉得生活美好。

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

如若内容造成侵权/违法违规/事实不符,请联系编程知识网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

4.2学习总结

解题思路 遍历初始整数的全排列,然后计算每一个排列与原排列的的步数找到花费的最小值就行了 代码 #include <iostream> #include <cstdio> #include <fstream> #include <algorithm> #include <cmath> #include <deque> #include <…

PEFT-LISA

LISA是LoRA的简化版&#xff0c;但其抓住了LoRA微调的核心&#xff0c;即LoRA侧重更新LLM的底层embedding和顶层head。 根据上述现象&#xff0c;LISA提出两点改进&#xff1a; 始终更新LLM的底层embedding和顶层head随机更新中间层的hidden state 实验结果 显存占用 毕竟模型…

QA测试开发工程师面试题满分问答5: 内存溢出和内存泄漏问题

概念阐述 内存溢出&#xff08;Memory Overflow&#xff09;和内存泄漏&#xff08;Memory Leak&#xff09;是与计算机程序中的内存管理相关的问题&#xff0c;它们描述了不同的情况。 内存溢出是指程序在申请内存时&#xff0c;要求的内存超出了系统所能提供的可用内存资源…

el-table实现表格内部横向拖拽效果

2024.4.2今天我学习了如何对el-table表格组件实现内部横向拖拽的效果&#xff0c;效果&#xff1a; 代码如下&#xff1a; 一、创建utils/底下文件 const crosswise_drag_table function (Vue){// 全局添加table左右拖动效果的指令Vue.directive(tableMove, {bind: function…

【信贷后台管理系统之axios的二次封装(四)】

文章目录 一、axios的二次封装二、配置后端接口地址三、登录接口api联调四、贷款申请接口api编写联调 一、axios的二次封装 示例&#xff1a;pandas 是基于NumPy 的一种工具&#xff0c;该工具是为了解决数据分析任务而创建的。 src下新建utils,新建request.js用来封装axios 控…

Vue-Next-Admin:适配手机、平板、PC的开源后台管理模板

摘要&#xff1a;随着移动设备和PC的普及&#xff0c;为了满足不同设备的需求&#xff0c;开发一个能够自适应手机、平板和PC的后台管理系统变得至关重要。本文将介绍一个基于Vue3.x、Typescript、Vite、Element Plus等技术的开源模板库——Vue-Next-Admin&#xff0c;帮助开发…

Java多线程实战-从零手搓一个简易线程池(三)线程工厂,核心线程与非核心线程逻辑实现

&#x1f3f7;️个人主页&#xff1a;牵着猫散步的鼠鼠 &#x1f3f7;️系列专栏&#xff1a;Java全栈-专栏 &#x1f3f7;️本系列源码仓库&#xff1a;多线程并发编程学习的多个代码片段(github) &#x1f3f7;️个人学习笔记&#xff0c;若有缺误&#xff0c;欢迎评论区指正…

flink on yarn

前言 Apache Flink&#xff0c;作为大数据处理领域的璀璨明星&#xff0c;以其独特的流处理和批处理一体化模型&#xff0c;成为众多企业和开发者的首选。它不仅能够在处理无界数据流时展现出卓越的实时性能&#xff0c;还能在有界数据批处理上达到高效稳定的效果。本文将简要…

网络协议学习——HTTPS

目录 ​编辑 一&#xff0c;认识HTTPS 二&#xff0c;加密方式 1&#xff0c;对称式加密 2&#xff0c;非对称式的加密 3&#xff0c;数据指纹&#xff08;数据摘要&#xff09; 4&#xff0c;数据签名 三&#xff0c;HTTPS的工作原理 实现方式 数字证书 一&#xff0c…

pygame--坦克大战(二)

加载敌方坦克 敌方坦克的方向是随机的&#xff0c;使用随机数生成。 初始化敌方坦克。 class EnemyTank(Tank):def __init__(self,left,top,speed):self.images {U: pygame.image.load(img/enemy1U.gif),D: pygame.image.load(img/enemy1D.gif),L: pygame.image.load(img/e…

Golang学习系列1-pprof性能调优

1. pprof 简述 一位亦师亦友的话让我记忆犹新&#xff0c;他说“学习一个新事务&#xff0c;应该从三个方面入手what,why,how;且三者的重要程度应该是递减”。所以在本文的第一部分先叙述下pprof的what & why。 1.1 What&#xff1f; pprof是golang自身提供的一种性能分…

大模型量化技术-GPTQ

大模型量化技术-GPTQ 2022年,Frantar等人发表了论文 GPTQ:Accurate Post-Training Quantization for Generative Pre-trained Transformers。 这篇论文详细介绍了一种训练后量化算法,适用于所有通用的预训练 Transformer模型,同时只有微小的性能下降。 GPTQ算法需要通过…