FastThreadLocal快在哪里
blog.csdn.net/mycs2012/article/details/90898128
1 fastthreadlocal的引入背景和原理简介既然jdk已经有threadlocal，为何netty还要自己造个fastthreadlocal？fastthreadlocal快在哪里？
这需要从jdk threadlocal的本身说起。如下图：
在java线程中，每个线程都有一个threadlocalmap实例变量（如果不使用threadlocal，不会创建这个map，一个线程第一次访问某个threadlocal变量时，才会创建）。
该map是使用线性探测的方式解决hash冲突的问题，如果没有找到空闲的slot，就不断往后尝试，直到找到一个空闲的位置，插入entry，这种方式在经常遇到hash冲突时，影响效率。
fastthreadlocal（下文简称ftl）直接使用数组避免了hash冲突的发生，具体做法是：每一个fastthreadlocal实例创建时，分配一个下标index；分配index使用atomicinteger实现，每个fastthreadlocal都能获取到一个不重复的下标。
当调用ftl.get（）方法获取值时，直接从数组获取返回，如return array［index］，如下图：
2 实现源码分析根据上文图示可知，ftl的实现，涉及到internalthreadlocalmap、fastthreadlocalthread和fastthreadlocal几个类，自底向上，我们先从internalthreadlocalmap开始分析。
internalthreadlocalmap类的继承关系图如下：
2.1 unpaddedinternalthreadlocalmap的主要属性
static final threadlocal《internalthreadlocalmap》 slowthreadlocalmap = new threadlocal《internalthreadlocalmap》（）;
static final atomicinteger nextindex = new atomicinteger（）;
object［］ indexedvariables;
数组indexedvariables就是用来存储ftl的value的，使用下标的方式直接访问。nextindex在ftl实例创建时用来给每个ftl实例分配一个下标，slowthreadlocalmap在线程不是ftlt时使用到。
2.2 internalthreadlocalmap分析
internalthreadlocalmap的主要属性：
// 用于标识数组的槽位还未使用public static final object unset = new object（）;
/**
* 用于标识ftl变量是否注册了cleaner
* bitset简要原理：
* bitset默认底层数据结构是一个long［］数组，开始时长度为1，即只有long［0］，而一个long有64bit。
* 当bitset.set（1）的时候，表示将long［0］的第二位设置为true，即0000 0000 。.. 0010（64bit），则long［0］==2
* 当bitset.get（1）的时候，第二位为1，则表示true；如果是0，则表示false
* 当bitset.set（64）的时候，表示设置第65位，此时long［0］已经不够用了，扩容处long［1］来，进行存储
*
* 存储类似 {index:boolean} 键值对，用于防止一个fastthreadlocal多次启动清理线程
* 将index位置的bit设为true，表示该internalthreadlocalmap中对该fastthreadlocal已经启动了清理线程
*/private bitset cleanerflags;
private internalthreadlocalmap（） {
super（newindexedvariabletable（））;
}
private static object［］ newindexedvariabletable（） {
object［］ array = new object［32］;
arrays.fill（array， unset）;
return array;
}
比较简单，newindexedvariabletable（）方法创建长度为32的数组，然后初始化为unset，然后传给父类。之后ftl的值就保存到这个数组里面。
注意，这里保存的直接是变量值，不是entry，这是和jdk threadlocal不同的。internalthreadlocalmap就先分析到这，其他方法在后面分析ftl再具体说。
2.3 ftlt的实现分析
要发挥ftl的性能优势，必须和ftlt结合使用，否则就会退化到jdk的threadlocal。ftlt比较简单，关键代码如下：
public class fastthreadlocalthread extends thread {
// this will be set to true if we have a chance to wrap the runnable.
private final boolean cleanupfastthreadlocals;
private internalthreadlocalmap threadlocalmap;
public final internalthreadlocalmap threadlocalmap（） {
return threadlocalmap;
}
public final void setthreadlocalmap（internalthreadlocalmap threadlocalmap） {
this.threadlocalmap = threadlocalmap;
}
}
ftlt的诀窍就在threadlocalmap属性，它继承java thread，然后聚合了自己的internalthreadlocalmap。后面访问ftl变量，对于ftlt线程，都直接从internalthreadlocalmap获取变量值。
2.4 ftl实现分析
ftl实现分析基于netty-4.1.34版本，特别地声明了版本，是因为在清除的地方，该版本的源码已经注释掉了objectcleaner的调用，和之前的版本有所不同。
2.4.1 ftl的属性和实例化
private final int index;
public fastthreadlocal（） {
index = internalthreadlocalmap.nextvariableindex（）;
}
非常简单，就是给属性index赋值，赋值的静态方法在internalthreadlocalmap：
public static int nextvariableindex（） {
int index = nextindex.getandincrement（）;
if （index 《 0） {
nextindex.decrementandget（）;
throw new illegalstateexception（“too many thread-local indexed variables”）;
}
return index;
}
可见，每个ftl实例以步长为1的递增序列，获取index值，这保证了internalthreadlocalmap中数组的长度不会突增。
2.4.2 get（）方法实现分析
public final v get（） {
internalthreadlocalmap threadlocalmap = internalthreadlocalmap.get（）; // 1
object v = threadlocalmap.indexedvariable（index）; // 2
if （v ！= internalthreadlocalmap.unset） {
return （v） v;
}
v value = initialize（threadlocalmap）; // 3
registercleaner（threadlocalmap）; // 4
return value;
}
1.先来看看internalthreadlocalmap.get（）方法如何获取threadlocalmap：
=======================internalthreadlocalmap=======================
public static internalthreadlocalmap get（） {
thread thread = thread.currentthread（）;
if （thread instanceof fastthreadlocalthread） {
return fastget（（fastthreadlocalthread） thread）;
} else {
return slowget（）;
}
}
private static internalthreadlocalmap fastget（fastthreadlocalthread thread） {
internalthreadlocalmap threadlocalmap = thread.threadlocalmap（）;
if （threadlocalmap == null） {
thread.setthreadlocalmap（threadlocalmap = new internalthreadlocalmap（））;
}
return threadlocalmap;
}
因为结合fastthreadlocalthread使用才能发挥fastthreadlocal的性能优势，所以主要看fastget方法。该方法直接从ftlt线程获取threadlocalmap，还没有则创建一个internalthreadlocalmap实例并设置进去，然后返回。学习资料：java进阶视频资源
2.threadlocalmap.indexedvariable（index）就简单了，直接从数组获取值，然后返回：
public object indexedvariable（int index） {
object［］ lookup = indexedvariables;
return index 《 lookup.length？ lookup［index］ ： unset;
}
3.如果获取到的值不是unset，那么是个有效的值，直接返回。如果是unset，则初始化。
initialize（threadlocalmap）方法：
private v initialize（internalthreadlocalmap threadlocalmap） {
v v = null;
try {
v = initialvalue（）;
} catch （exception e） {
platformdependent.throwexception（e）;
}
threadlocalmap.setindexedvariable（index， v）; // 3-1
addtovariablestoremove（threadlocalmap， this）; // 3-2
return v;
}
3.1.获取ftl的初始值，然后保存到ftl里的数组，如果数组长度不够则扩充数组长度，然后保存，不展开。
3.2.addtovariablestoremove（threadlocalmap， this）的实现，是将ftl实例保存在threadlocalmap内部数组第0个元素的set集合中。
4.registercleaner（threadlocalmap）的实现，netty-4.1.34版本中的源码：
private void registercleaner（final internalthreadlocalmap threadlocalmap） {
thread current = thread.currentthread（）;
if （fastthreadlocalthread.willcleanupfastthreadlocals（current） || threadlocalmap.iscleanerflagset（index）） {
return;
}
threadlocalmap.setcleanerflag（index）;
// todo： we need to find a better way to handle this.
/*
// we will need to ensure we will trigger remove（internalthreadlocalmap） so everything will be released
// and fastthreadlocal.onremoval（。..） will be called.
objectcleaner.register（current， new runnable（） {
@override
public void run（） {
remove（threadlocalmap）;
// it‘s fine to not call internalthreadlocalmap.remove（） here as this will only be triggered once
// the thread is collected by gc. in this case the threadlocal will be gone away already.
}
}）;
*/
}
由于objectcleaner.register这段代码在该版本已经注释掉，而余下逻辑比较简单，因此不再做分析。
2.5 普通线程使用ftl的性能退化
随着get（）方法分析完毕，set（value）方法原理也呼之欲出，限于篇幅，不再单独分析。
前文说过，ftl要结合ftlt才能最大地发挥其性能，如果是其他的普通线程，就会退化到jdk的threadlocal的情况，因为普通线程没有包含internalthreadlocalmap这样的数据结构，接下来我们看如何退化。学习资料：java进阶视频资源
从internalthreadlocalmap的get（）方法看起：
=======================internalthreadlocalmap=======================
public static internalthreadlocalmap get（） {
thread thread = thread.currentthread（）;
if （thread instanceof fastthreadlocalthread） {
return fastget（（fastthreadlocalthread） thread）;
} else {
return slowget（）;
}
}
private static internalthreadlocalmap slowget（） {
// 父类的类型为jdk threadlocald的静态属性，从该threadlocal获取internalthreadlocalmap
threadlocal《internalthreadlocalmap》 slowthreadlocalmap = unpaddedinternalthreadlocalmap.slowthreadlocalmap;
internalthreadlocalmap ret = slowthreadlocalmap.get（）;
if （ret == null） {
ret = new internalthreadlocalmap（）;
slowthreadlocalmap.set（ret）;
}
return ret;
}
从ftl看，退化操作的整个流程是：从一个jdk的threadlocal变量中获取internalthreadlocalmap，然后再从internalthreadlocalmap获取指定数组下标的值，对象关系示意图：
3 ftl的资源回收机制在netty中对于ftl提供了三种回收机制：
自动： 使用ftlt执行一个被fastthreadlocalrunnable wrap的runnable任务，在任务执行完毕后会自动进行ftl的清理。
手动： ftl和internalthreadlocalmap都提供了remove方法，在合适的时候用户可以（有的时候也是必须，例如普通线程的线程池使用ftl）手动进行调用，进行显示删除。
自动： 为当前线程的每一个ftl注册一个cleaner，当线程对象不强可达的时候，该cleaner线程会将当前线程的当前ftl进行回收。（netty推荐如果可以用其他两种方式，就不要再用这种方式，因为需要另起线程，耗费资源，而且多线程就会造成一些资源竞争，在netty-4.1.34版本中，已经注释掉了调用objectcleaner的代码。）
4 ftl在netty中的使用ftl在netty中最重要的使用，就是分配bytebuf。基本做法是：每个线程都分配一块内存（poolarena），当需要分配bytebuf时，线程先从自己持有的poolarena分配，如果自己无法分配，再采用全局分配。
但是由于内存资源有限，所以还是会有多个线程持有同一块poolarena的情况。不过这种方式已经最大限度地减轻了多线程的资源竞争，提高程序效率。
具体的代码在poolbytebufallocator的内部类poolthreadlocalcache中：
final class poolthreadlocalcache extends fastthreadlocal《poolthreadcache》 {
@override
protected synchronized poolthreadcache initialvalue（） {
final poolarena《byte［］》 heaparena = leastusedarena（heaparenas）;
final poolarena《bytebuffer》 directarena = leastusedarena（directarenas）;
thread current = thread.currentthread（）;
if （usecacheforallthreads || current instanceof fastthreadlocalthread） {
// poolthreadcache即为各个线程持有的内存块的封装
return new poolthreadcache（
heaparena， directarena， tinycachesize， smallcachesize， normalcachesize，
default_max_cached_buffer_capacity， default_cache_trim_interval）;
}
// no caching so just use 0 as sizes.
return new poolthreadcache（heaparena， directarena， 0， 0， 0， 0， 0）;
}
}
英飞凌采用具有新额定电流的IGBT7以增强1200V EconoDUAL™ 3产品组合，灵活满足更高的功率密度和性能
iPhone8发布一个月降价800，港版跌破5000，iPhone7系列价格却依旧坚挺，苹果到底怎么了？
亚马逊宣布推出Build It新平台
冬天应该如何保养和使用无人机
博通以太网光纤通道解决方案
FastThreadLocal快在哪里
短期内，鸿蒙会否继续取代安卓
用TDA1521制作的小型功放及音箱,TDA1521 AMPLIFIER
最后是谁吃了亏！伟创力工厂已停产，因华为剔除其供应链
苹果又搞鬼？iPhone X用发烫后狂降频：性能跌到3成
Allegro MicroSystems发布集成有霍尔效应开关的微功率LED驱动器
光伏路线之争，未来5年是关键期
核电DCS是否要引入边缘计算技术？
低待机功耗是便携式医疗设备的关键需求
综合布线技术中网线配对技术
AI进化速度惊人 Arm/赛灵思合力共推研华AI化生产线
智能音箱竞争白热化 Amazon与Apple智能音箱的区别是什么
盘古大模型和阿里哪个好？
改进的LDO稳压器吸收PECL端接电流
真正理解边缘人工智能，得先了解边缘计算
1 fastthreadlocal的引入背景和原理简介既然jdk已经有threadlocal，为何netty还要自己造个fastthreadlocal？fastthreadlocal快在哪里？
这需要从jdk threadlocal的本身说起。如下图：
在java线程中，每个线程都有一个threadlocalmap实例变量（如果不使用threadlocal，不会创建这个map，一个线程第一次访问某个threadlocal变量时，才会创建）。
该map是使用线性探测的方式解决hash冲突的问题，如果没有找到空闲的slot，就不断往后尝试，直到找到一个空闲的位置，插入entry，这种方式在经常遇到hash冲突时，影响效率。
fastthreadlocal（下文简称ftl）直接使用数组避免了hash冲突的发生，具体做法是：每一个fastthreadlocal实例创建时，分配一个下标index；分配index使用atomicinteger实现，每个fastthreadlocal都能获取到一个不重复的下标。
当调用ftl.get（）方法获取值时，直接从数组获取返回，如return array［index］，如下图：
2 实现源码分析根据上文图示可知，ftl的实现，涉及到internalthreadlocalmap、fastthreadlocalthread和fastthreadlocal几个类，自底向上，我们先从internalthreadlocalmap开始分析。
internalthreadlocalmap类的继承关系图如下：
2.1 unpaddedinternalthreadlocalmap的主要属性
static final threadlocal《internalthreadlocalmap》 slowthreadlocalmap = new threadlocal《internalthreadlocalmap》（）;
static final atomicinteger nextindex = new atomicinteger（）;
object［］ indexedvariables;
数组indexedvariables就是用来存储ftl的value的，使用下标的方式直接访问。nextindex在ftl实例创建时用来给每个ftl实例分配一个下标，slowthreadlocalmap在线程不是ftlt时使用到。
2.2 internalthreadlocalmap分析
internalthreadlocalmap的主要属性：
// 用于标识数组的槽位还未使用public static final object unset = new object（）;
/**
* 用于标识ftl变量是否注册了cleaner
* bitset简要原理：
* bitset默认底层数据结构是一个long［］数组，开始时长度为1，即只有long［0］，而一个long有64bit。
* 当bitset.set（1）的时候，表示将long［0］的第二位设置为true，即0000 0000 。.. 0010（64bit），则long［0］==2
* 当bitset.get（1）的时候，第二位为1，则表示true；如果是0，则表示false
* 当bitset.set（64）的时候，表示设置第65位，此时long［0］已经不够用了，扩容处long［1］来，进行存储
*
* 存储类似 {index:boolean} 键值对，用于防止一个fastthreadlocal多次启动清理线程
* 将index位置的bit设为true，表示该internalthreadlocalmap中对该fastthreadlocal已经启动了清理线程
*/private bitset cleanerflags;
private internalthreadlocalmap（） {
super（newindexedvariabletable（））;
}
private static object［］ newindexedvariabletable（） {
object［］ array = new object［32］;
arrays.fill（array， unset）;
return array;
}
比较简单，newindexedvariabletable（）方法创建长度为32的数组，然后初始化为unset，然后传给父类。之后ftl的值就保存到这个数组里面。
注意，这里保存的直接是变量值，不是entry，这是和jdk threadlocal不同的。internalthreadlocalmap就先分析到这，其他方法在后面分析ftl再具体说。
2.3 ftlt的实现分析
要发挥ftl的性能优势，必须和ftlt结合使用，否则就会退化到jdk的threadlocal。ftlt比较简单，关键代码如下：
public class fastthreadlocalthread extends thread {
// this will be set to true if we have a chance to wrap the runnable.
private final boolean cleanupfastthreadlocals;
private internalthreadlocalmap threadlocalmap;
public final internalthreadlocalmap threadlocalmap（） {
return threadlocalmap;
}
public final void setthreadlocalmap（internalthreadlocalmap threadlocalmap） {
this.threadlocalmap = threadlocalmap;
}
}
ftlt的诀窍就在threadlocalmap属性，它继承java thread，然后聚合了自己的internalthreadlocalmap。后面访问ftl变量，对于ftlt线程，都直接从internalthreadlocalmap获取变量值。
2.4 ftl实现分析
ftl实现分析基于netty-4.1.34版本，特别地声明了版本，是因为在清除的地方，该版本的源码已经注释掉了objectcleaner的调用，和之前的版本有所不同。
2.4.1 ftl的属性和实例化
private final int index;
public fastthreadlocal（） {
index = internalthreadlocalmap.nextvariableindex（）;
}
非常简单，就是给属性index赋值，赋值的静态方法在internalthreadlocalmap：
public static int nextvariableindex（） {
int index = nextindex.getandincrement（）;
if （index 《 0） {
nextindex.decrementandget（）;
throw new illegalstateexception（“too many thread-local indexed variables”）;
}
return index;
}
可见，每个ftl实例以步长为1的递增序列，获取index值，这保证了internalthreadlocalmap中数组的长度不会突增。
2.4.2 get（）方法实现分析
public final v get（） {
internalthreadlocalmap threadlocalmap = internalthreadlocalmap.get（）; // 1
object v = threadlocalmap.indexedvariable（index）; // 2
if （v ！= internalthreadlocalmap.unset） {
return （v） v;
}
v value = initialize（threadlocalmap）; // 3
registercleaner（threadlocalmap）; // 4
return value;
}
1.先来看看internalthreadlocalmap.get（）方法如何获取threadlocalmap：
=======================internalthreadlocalmap=======================
public static internalthreadlocalmap get（） {
thread thread = thread.currentthread（）;
if （thread instanceof fastthreadlocalthread） {
return fastget（（fastthreadlocalthread） thread）;
} else {
return slowget（）;
}
}
private static internalthreadlocalmap fastget（fastthreadlocalthread thread） {
internalthreadlocalmap threadlocalmap = thread.threadlocalmap（）;
if （threadlocalmap == null） {
thread.setthreadlocalmap（threadlocalmap = new internalthreadlocalmap（））;
}
return threadlocalmap;
}
因为结合fastthreadlocalthread使用才能发挥fastthreadlocal的性能优势，所以主要看fastget方法。该方法直接从ftlt线程获取threadlocalmap，还没有则创建一个internalthreadlocalmap实例并设置进去，然后返回。学习资料：java进阶视频资源
2.threadlocalmap.indexedvariable（index）就简单了，直接从数组获取值，然后返回：
public object indexedvariable（int index） {
object［］ lookup = indexedvariables;
return index 《 lookup.length？ lookup［index］ ： unset;
}
3.如果获取到的值不是unset，那么是个有效的值，直接返回。如果是unset，则初始化。
initialize（threadlocalmap）方法：
private v initialize（internalthreadlocalmap threadlocalmap） {
v v = null;
try {
v = initialvalue（）;
} catch （exception e） {
platformdependent.throwexception（e）;
}
threadlocalmap.setindexedvariable（index， v）; // 3-1
addtovariablestoremove（threadlocalmap， this）; // 3-2
return v;
}
3.1.获取ftl的初始值，然后保存到ftl里的数组，如果数组长度不够则扩充数组长度，然后保存，不展开。
3.2.addtovariablestoremove（threadlocalmap， this）的实现，是将ftl实例保存在threadlocalmap内部数组第0个元素的set集合中。
4.registercleaner（threadlocalmap）的实现，netty-4.1.34版本中的源码：
private void registercleaner（final internalthreadlocalmap threadlocalmap） {
thread current = thread.currentthread（）;
if （fastthreadlocalthread.willcleanupfastthreadlocals（current） || threadlocalmap.iscleanerflagset（index）） {
return;
}
threadlocalmap.setcleanerflag（index）;
// todo： we need to find a better way to handle this.
/*
// we will need to ensure we will trigger remove（internalthreadlocalmap） so everything will be released
// and fastthreadlocal.onremoval（。..） will be called.
objectcleaner.register（current， new runnable（） {
@override
public void run（） {
remove（threadlocalmap）;
// it‘s fine to not call internalthreadlocalmap.remove（） here as this will only be triggered once
// the thread is collected by gc. in this case the threadlocal will be gone away already.
}
}）;
*/
}
由于objectcleaner.register这段代码在该版本已经注释掉，而余下逻辑比较简单，因此不再做分析。
2.5 普通线程使用ftl的性能退化
随着get（）方法分析完毕，set（value）方法原理也呼之欲出，限于篇幅，不再单独分析。
前文说过，ftl要结合ftlt才能最大地发挥其性能，如果是其他的普通线程，就会退化到jdk的threadlocal的情况，因为普通线程没有包含internalthreadlocalmap这样的数据结构，接下来我们看如何退化。学习资料：java进阶视频资源
从internalthreadlocalmap的get（）方法看起：
=======================internalthreadlocalmap=======================
public static internalthreadlocalmap get（） {
thread thread = thread.currentthread（）;
if （thread instanceof fastthreadlocalthread） {
return fastget（（fastthreadlocalthread） thread）;
} else {
return slowget（）;
}
}
private static internalthreadlocalmap slowget（） {
// 父类的类型为jdk threadlocald的静态属性，从该threadlocal获取internalthreadlocalmap
threadlocal《internalthreadlocalmap》 slowthreadlocalmap = unpaddedinternalthreadlocalmap.slowthreadlocalmap;
internalthreadlocalmap ret = slowthreadlocalmap.get（）;
if （ret == null） {
ret = new internalthreadlocalmap（）;
slowthreadlocalmap.set（ret）;
}
return ret;
}
从ftl看，退化操作的整个流程是：从一个jdk的threadlocal变量中获取internalthreadlocalmap，然后再从internalthreadlocalmap获取指定数组下标的值，对象关系示意图：
3 ftl的资源回收机制在netty中对于ftl提供了三种回收机制：
自动： 使用ftlt执行一个被fastthreadlocalrunnable wrap的runnable任务，在任务执行完毕后会自动进行ftl的清理。
手动： ftl和internalthreadlocalmap都提供了remove方法，在合适的时候用户可以（有的时候也是必须，例如普通线程的线程池使用ftl）手动进行调用，进行显示删除。
自动： 为当前线程的每一个ftl注册一个cleaner，当线程对象不强可达的时候，该cleaner线程会将当前线程的当前ftl进行回收。（netty推荐如果可以用其他两种方式，就不要再用这种方式，因为需要另起线程，耗费资源，而且多线程就会造成一些资源竞争，在netty-4.1.34版本中，已经注释掉了调用objectcleaner的代码。）
4 ftl在netty中的使用ftl在netty中最重要的使用，就是分配bytebuf。基本做法是：每个线程都分配一块内存（poolarena），当需要分配bytebuf时，线程先从自己持有的poolarena分配，如果自己无法分配，再采用全局分配。
但是由于内存资源有限，所以还是会有多个线程持有同一块poolarena的情况。不过这种方式已经最大限度地减轻了多线程的资源竞争，提高程序效率。
具体的代码在poolbytebufallocator的内部类poolthreadlocalcache中：
final class poolthreadlocalcache extends fastthreadlocal《poolthreadcache》 {
@override
protected synchronized poolthreadcache initialvalue（） {
final poolarena《byte［］》 heaparena = leastusedarena（heaparenas）;
final poolarena《bytebuffer》 directarena = leastusedarena（directarenas）;
thread current = thread.currentthread（）;
if （usecacheforallthreads || current instanceof fastthreadlocalthread） {
// poolthreadcache即为各个线程持有的内存块的封装
return new poolthreadcache（
heaparena， directarena， tinycachesize， smallcachesize， normalcachesize，
default_max_cached_buffer_capacity， default_cache_trim_interval）;
}
// no caching so just use 0 as sizes.
return new poolthreadcache（heaparena， directarena， 0， 0， 0， 0， 0）;
}
}
英飞凌采用具有新额定电流的IGBT7以增强1200V EconoDUAL™ 3产品组合，灵活满足更高的功率密度和性能
iPhone8发布一个月降价800，港版跌破5000，iPhone7系列价格却依旧坚挺，苹果到底怎么了？
亚马逊宣布推出Build It新平台
冬天应该如何保养和使用无人机
博通以太网光纤通道解决方案
FastThreadLocal快在哪里
短期内，鸿蒙会否继续取代安卓
用TDA1521制作的小型功放及音箱,TDA1521 AMPLIFIER
最后是谁吃了亏！伟创力工厂已停产，因华为剔除其供应链
苹果又搞鬼？iPhone X用发烫后狂降频：性能跌到3成
Allegro MicroSystems发布集成有霍尔效应开关的微功率LED驱动器
光伏路线之争，未来5年是关键期
核电DCS是否要引入边缘计算技术？
低待机功耗是便携式医疗设备的关键需求
综合布线技术中网线配对技术
AI进化速度惊人 Arm/赛灵思合力共推研华AI化生产线
智能音箱竞争白热化 Amazon与Apple智能音箱的区别是什么
盘古大模型和阿里哪个好？
改进的LDO稳压器吸收PECL端接电流
真正理解边缘人工智能，得先了解边缘计算