面试必备：ThreadLocal详解

前言

大家好，我是捡田螺的小男孩。

无论是工作还是面试，我们都会跟ThreadLocal打交道，今天就跟大家聊聊ThreadLocal哈~

  1. ThreadLocal是什么?为什么要使用ThreadLocal
  2. 一个ThreadLocal的使用案例
  3. ThreadLocal的原理
  4. 为什么不直接用线程id作为ThreadLocalMap的key
  5. 为什么会导致内存泄漏呢？是因为弱引用吗？
  6. Key为什么要设计成弱引用呢？强引用不行？
  7. InheritableThreadLocal保证父子线程间的共享数据
  8. ThreadLocal的应用场景和使用注意点

1. ThreadLocal是什么?为什么要使用ThreadLocal？

ThreadLocal是什么?

ThreadLocal，即线程本地变量。如果你创建了一个ThreadLocal变量，那么访问这个变量的每个线程都会有这个变量的一个本地拷贝，多个线程操作这个变量的时候，实际是在操作自己本地内存里面的变量，从而起到线程隔离的作用，避免了并发场景下的线程安全问题。

//创建一个ThreadLocal变量static ThreadLocal localVariable = new ThreadLocal<>();复制代码

为什么要使用ThreadLocal

并发场景下，会存在多个线程同时修改一个共享变量的场景。这就可能会出现线性安全问题。

为了解决线性安全问题，可以用加锁的方式，比如使用synchronized 或者Lock。但是加锁的方式，可能会导致系统变慢。加锁示意图如下：

还有另外一种方案，就是使用空间换时间的方式，即使用ThreadLocal。使用ThreadLocal类访问共享变量时，会在每个线程的本地，都保存一份共享变量的拷贝副本。多线程对共享变量修改时，实际上操作的是这个变量副本，从而保证线性安全。

2. 一个ThreadLocal的使用案例

日常开发中，ThreadLocal经常在日期转换工具类中出现，我们先来看个反例：

/** * 日期工具类 */public class DateUtil {    private static final SimpleDateFormat simpleDateFormat =            new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");    public static Date parse(String dateString) {        Date date = null;        try {            date = simpleDateFormat.parse(dateString);        } catch (ParseException e) {            e.printStackTrace();        }        return date;    }}复制代码

我们在多线程环境跑DateUtil这个工具类：

public static void main(String[] args) {        ExecutorService executorService = Executors.newFixedThreadPool(10);        for (int i = 0; i < 10; i++) {            executorService.execute(()->{                System.out.println(DateUtil.parse("2022-07-24 16:34:30"));            });        }        executorService.shutdown();    }复制代码

运行后，发现报错了：

如果在DateUtil工具类，加上ThreadLocal，运行则不会有这个问题：

/** * 日期工具类 */public class DateUtil {    private static ThreadLocal dateFormatThreadLocal =            ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));    public static Date parse(String dateString) {        Date date = null;        try {            date = dateFormatThreadLocal.get().parse(dateString);        } catch (ParseException e) {            e.printStackTrace();        }        return date;    }    public static void main(String[] args) {        ExecutorService executorService = Executors.newFixedThreadPool(10);        for (int i = 0; i < 10; i++) {            executorService.execute(()->{                System.out.println(DateUtil.parse("2022-07-24 16:34:30"));            });        }        executorService.shutdown();    }}复制代码

运行结果：

Sun Jul 24 16:34:30 GMT+08:00 2022Sun Jul 24 16:34:30 GMT+08:00 2022Sun Jul 24 16:34:30 GMT+08:00 2022Sun Jul 24 16:34:30 GMT+08:00 2022Sun Jul 24 16:34:30 GMT+08:00 2022Sun Jul 24 16:34:30 GMT+08:00 2022Sun Jul 24 16:34:30 GMT+08:00 2022Sun Jul 24 16:34:30 GMT+08:00 2022Sun Jul 24 16:34:30 GMT+08:00 2022Sun Jul 24 16:34:30 GMT+08:00 2022复制代码

刚刚反例中，为什么会报错呢？这是因为SimpleDateFormat不是线性安全的，它以共享变量出现时，并发多线程场景下即会报错。

为什么加了ThreadLocal就不会有问题呢？并发场景下，ThreadLocal是如何保证的呢？我们接下来看看ThreadLocal的核心原理。

3. ThreadLocal的原理

3.1 ThreadLocal的内存结构图

为了有个宏观的认识，我们先来看下ThreadLocal的内存结构图

从内存结构图，我们可以看到：

3.2 关键源码分析

对照着几段关键源码来看，更容易理解一点哈~我们回到Thread类源码，可以看到成员变量ThreadLocalMap的初始值是为null

public class Thread implements Runnable {   //ThreadLocal.ThreadLocalMap是Thread的属性   ThreadLocal.ThreadLocalMap threadLocals = null;}复制代码

ThreadLocalMap的关键源码如下：

static class ThreadLocalMap {        static class Entry extends WeakReference> {        /** The value associated with this ThreadLocal. */        Object value;        Entry(ThreadLocal<?> k, Object v) {            super(k);            value = v;        }    }    //Entry数组    private Entry[] table;        // ThreadLocalMap的构造器，ThreadLocal作为key    ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {        table = new Entry[INITIAL_CAPACITY];        int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);        table[i] = new Entry(firstKey, firstValue);        size = 1;        setThreshold(INITIAL_CAPACITY);    }}复制代码

ThreadLocal类中的关键set()方法：

 public void set(T value) {        Thread t = Thread.currentThread(); //获取当前线程t        ThreadLocalMap map = getMap(t);  //根据当前线程获取到ThreadLocalMap        if (map != null)  //如果获取的ThreadLocalMap对象不为空            map.set(this, value); //K，V设置到ThreadLocalMap中        else            createMap(t, value); //创建一个新的ThreadLocalMap    }         ThreadLocalMap getMap(Thread t) {       return t.threadLocals; //返回Thread对象的ThreadLocalMap属性    }    void createMap(Thread t, T firstValue) { //调用ThreadLocalMap的构造函数        t.threadLocals = new ThreadLocalMap(this, firstValue); this表示当前类ThreadLocal    }    复制代码

ThreadLocal类中的关键get()方法

    public T get() {        Thread t = Thread.currentThread();//获取当前线程t        ThreadLocalMap map = getMap(t);//根据当前线程获取到ThreadLocalMap        if (map != null) { //如果获取的ThreadLocalMap对象不为空            //由this（即ThreadLoca对象）得到对应的Value，即ThreadLocal的泛型值            ThreadLocalMap.Entry e = map.getEntry(this);            if (e != null) {                @SuppressWarnings("unchecked")                T result = (T)e.value;                 return result;            }        }        return setInitialValue(); //初始化threadLocals成员变量的值    }         private T setInitialValue() {        T value = initialValue(); //初始化value的值        Thread t = Thread.currentThread();         ThreadLocalMap map = getMap(t); //以当前线程为key，获取threadLocals成员变量，它是一个ThreadLocalMap        if (map != null)            map.set(this, value);  //K，V设置到ThreadLocalMap中        else            createMap(t, value); //实例化threadLocals成员变量        return value;    }复制代码

所以怎么回答ThreadLocal的实现原理？如下，最好是能结合以上结构图一起说明哈~

了解完这几个核心方法后，有些小伙伴可能会有疑惑，ThreadLocalMap为什么要用ThreadLocal作为key呢？直接用线程Id不一样嘛？

4. 为什么不直接用线程id作为ThreadLocalMap的key呢？

举个代码例子，如下：

public class TianLuoThreadLocalTest {    private static final ThreadLocal threadLocal1 = new ThreadLocal<>();    private static final ThreadLocal threadLocal2 = new ThreadLocal<>(); }复制代码

这种场景：一个使用类，有两个共享变量，也就是说用了两个ThreadLocal成员变量的话。如果用线程id作为ThreadLocalMap的key，怎么区分哪个ThreadLocal成员变量呢？因此还是需要使用ThreadLocal作为Key来使用。每个ThreadLocal对象，都可以由threadLocalHashCode属性唯一区分的，每一个ThreadLocal对象都可以由这个对象的名字唯一区分（下面的例子）。看下ThreadLocal代码：

public class ThreadLocal {  private final int threadLocalHashCode = nextHashCode();    private static int nextHashCode() {    return nextHashCode.getAndAdd(HASH_INCREMENT);  }}

然后我们再来看下一个代码例子：

public class TianLuoThreadLocalTest {    public static void main(String[] args) {        Thread t = new Thread(new Runnable(){            public void run(){                ThreadLocal threadLocal1 = new ThreadLocal<>();                threadLocal1.set(new TianLuoDTO("公众号：捡田螺的小男孩"));                System.out.println(threadLocal1.get());                ThreadLocal threadLocal2 = new ThreadLocal<>();                threadLocal2.set(new TianLuoDTO("公众号：程序员田螺"));                System.out.println(threadLocal2.get());            }});        t.start();    }}//运行结果TianLuoDTO{name='公众号：捡田螺的小男孩'}TianLuoDTO{name='公众号：程序员田螺'}复制代码

再对比下这个图，可能就更清晰一点啦：

5. TreadLocal为什么会导致内存泄漏呢？

5.1 弱引用导致的内存泄漏呢？

我们先来看看TreadLocal的引用示意图哈：

关于ThreadLocal内存泄漏，网上比较流行的说法是这样的：

ThreadLocalMap使用ThreadLocal的弱引用作为key，当ThreadLocal变量被手动设置为null，即一个ThreadLocal没有外部强引用来引用它，当系统GC时，ThreadLocal一定会被回收。这样的话，ThreadLocalMap中就会出现key为null的Entry，就没有办法访问这些key为null的Entry的value，如果当前线程再迟迟不结束的话(比如线程池的核心线程)，这些key为null的Entry的value就会一直存在一条强引用链：Thread变量 -> Thread对象 -> ThreaLocalMap -> Entry -> value -> Object 永远无法回收，造成内存泄漏。

当ThreadLocal变量被手动设置为null后的引用链图：

实际上，ThreadLocalMap的设计中已经考虑到这种情况。所以也加上了一些防护措施：即在ThreadLocal的get,set,remove方法，都会清除线程ThreadLocalMap里所有key为null的value。

源代码中，是有体现的，如ThreadLocalMap的set方法：

  private void set(ThreadLocal<?> key, Object value) {      Entry[] tab = table;      int len = tab.length;      int i = key.threadLocalHashCode & (len-1);      for (Entry e = tab[i];            e != null;            e = tab[i = nextIndex(i, len)]) {          ThreadLocal<?> k = e.get();          if (k == key) {              e.value = value;              return;          }           //如果k等于null,则说明该索引位之前放的key(threadLocal对象)被回收了,这通常是因为外部将threadLocal变量置为null,           //又因为entry对threadLocal持有的是弱引用,一轮GC过后,对象被回收。            //这种情况下,既然用户代码都已经将threadLocal置为null,那么也就没打算再通过该对象作为key去取到之前放入threadLocalMap的value, 因此ThreadLocalMap中会直接替换调这种不新鲜的entry。          if (k == null) {              replaceStaleEntry(key, value, i);              return;          }        }        tab[i] = new Entry(key, value);        int sz = ++size;        //触发一次Log2(N)复杂度的扫描,目的是清除过期Entry          if (!cleanSomeSlots(i, sz) && sz >= threshold)          rehash();    }复制代码

如ThreadLocal的get方法：

  public T get() {    Thread t = Thread.currentThread();    ThreadLocalMap map = getMap(t);    if (map != null) {        //去ThreadLocalMap获取Entry，方法里面有key==null的清除逻辑        ThreadLocalMap.Entry e = map.getEntry(this);        if (e != null) {            @SuppressWarnings("unchecked")            T result = (T)e.value;            return result;        }    }    return setInitialValue();}private Entry getEntry(ThreadLocal<?> key) {        int i = key.threadLocalHashCode & (table.length - 1);        Entry e = table[i];        if (e != null && e.get() == key)             return e;        else          //里面有key==null的清除逻辑          return getEntryAfterMiss(key, i, e);    }        private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {        Entry[] tab = table;        int len = tab.length;        while (e != null) {            ThreadLocal<?> k = e.get();            if (k == key)                return e;            // Entry的key为null,则表明没有外部引用,且被GC回收,是一个过期Entry            if (k == null)                expungeStaleEntry(i); //删除过期的Entry            else                i = nextIndex(i, len);            e = tab[i];        }        return null;    }复制代码

5.2 key是弱引用，GC回收会影响ThreadLocal的正常工作嘛？

到这里，有些小伙伴可能有疑问，ThreadLocal的key既然是弱引用.会不会GC贸然把key回收掉，进而影响ThreadLocal的正常使用？

弱引用:具有弱引用的对象拥有更短暂的生命周期。如果一个对象只有弱引用存在了，则下次GC将会回收掉该对象（不管当前内存空间足够与否）

其实不会的，因为有ThreadLocal变量引用着它，是不会被GC回收的，除非手动把ThreadLocal变量设置为null，我们可以跑个demo来验证一下：

  public class WeakReferenceTest {    public static void main(String[] args) {        Object object = new Object();        WeakReference testWeakReference = new WeakReference<>(object);        System.out.println("GC回收之前，弱引用："+testWeakReference.get());        //触发系统垃圾回收        System.gc();        System.out.println("GC回收之后，弱引用："+testWeakReference.get());        //手动设置为object对象为null        object=null;        System.gc();        System.out.println("对象object设置为null，GC回收之后，弱引用："+testWeakReference.get());    }}运行结果：GC回收之前，弱引用：java.lang.Object@7b23ec81GC回收之后，弱引用：java.lang.Object@7b23ec81对象object设置为null，GC回收之后，弱引用：null复制代码
结论就是，小伙伴放下这个疑惑了，哈哈~
5.3 ThreadLocal内存泄漏的demo
给大家来看下一个内存泄漏的例子，其实就是用线程池，一直往里面放对象
public class ThreadLocalTestDemo {    private static ThreadLocal tianLuoThreadLocal = new ThreadLocal<>();    public static void main(String[] args) throws InterruptedException {        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 5, 1, TimeUnit.MINUTES, new LinkedBlockingQueue<>());        for (int i = 0; i < 10; ++i) {            threadPoolExecutor.execute(new Runnable() {                @Override                public void run() {                    System.out.println("创建对象：");                    TianLuoClass tianLuoClass = new TianLuoClass();                    tianLuoThreadLocal.set(tianLuoClass);                    tianLuoClass = null; //将对象设置为 null，表示此对象不在使用了                   // tianLuoThreadLocal.remove();                }            });            Thread.sleep(1000);        }    }    static class TianLuoClass {        // 100M        private byte[] bytes = new byte[100 * 1024 * 1024];    }}创建对象：创建对象：创建对象：创建对象：Exception in thread "pool-1-thread-4" java.lang.OutOfMemoryError: Java heap spaceat com.example.dto.ThreadLocalTestDemo$TianLuoClass.(ThreadLocalTestDemo.java:33)at com.example.dto.ThreadLocalTestDemo$1.run(ThreadLocalTestDemo.java:21)at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)at java.lang.Thread.run(Thread.java:748)复制代码
运行结果出现了OOM，tianLuoThreadLocal.remove();加上后，则不会OOM。
创建对象：创建对象：创建对象：创建对象：创建对象：创建对象：创建对象：创建对象：......复制代码
我们这里没有手动设置tianLuoThreadLocal变量为null，但是还是会内存泄漏。因为我们使用了线程池，线程池有很长的生命周期，因此线程池会一直持有tianLuoClass对象的value值，即使设置tianLuoClass = null;引用还是存在的。这就好像，你把一个个对象object放到一个list列表里，然后再单独把object设置为null的道理是一样的，列表的对象还是存在的。
    public static void main(String[] args) {        List list = new ArrayList<>();        Object object = new Object();        list.add(object);        object = null;        System.out.println(list.size());    }    //运行结果    1复制代码
所以内存泄漏就这样发生啦，最后内存是有限的，就抛出了OOM了。如果我们加上threadLocal.remove();，则不会内存泄漏。为什么呢？因为threadLocal.remove();会清除Entry，源码如下：
    private void remove(ThreadLocal<?> key) {      Entry[] tab = table;      int len = tab.length;      int i = key.threadLocalHashCode & (len-1);      for (Entry e = tab[i];          e != null;          e = tab[i = nextIndex(i, len)]) {          if (e.get() == key) {              //清除entry              e.clear();            expungeStaleEntry(i);            return;        }    }}复制代码
有些小伙伴说，既然内存泄漏不一定是因为弱引用，那为什么需要设计为弱引用呢？我们来探讨下：
6. Entry的Key为什么要设计成弱引用呢？
通过源码，我们是可以看到Entry的Key是设计为弱引用的(ThreadLocalMap使用ThreadLocal的弱引用作为Key的)。为什么要设计为弱引用呢？
我们先来回忆一下四种引用：
  • 强引用:我们平时new了一个对象就是强引用，例如 Object obj = new Object();即使在内存不足的情况下，JVM宁愿抛出OutOfMemory错误也不会回收这种对象。
  • 软引用：如果一个对象只具有软引用，则内存空间足够，垃圾回收器就不会回收它；如果内存空间不足了，就会回收这些对象的内存。
  • 弱引用:具有弱引用的对象拥有更短暂的生命周期。如果一个对象只有弱引用存在了，则下次GC将会回收掉该对象（不管当前内存空间足够与否）。
  • 虚引用:如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。虚引用主要用来跟踪对象被垃圾回收器回收的活动。
我们先来看看官方文档，为什么要设计为弱引用：
To help deal with very large and long-lived usages, the hash table entries use WeakReferences for keys.为了应对非常大和长时间的用途，哈希表使用弱引用的 key。复制代码
我再把ThreadLocal的引用示意图搬过来：
下面我们分情况讨论：
  • 如果Key使用强引用：当ThreadLocal的对象被回收了，但是ThreadLocalMap还持有ThreadLocal的强引用的话，如果没有手动删除，ThreadLocal就不会被回收，会出现Entry的内存泄漏问题。
  • 如果Key使用弱引用：当ThreadLocal的对象被回收了，因为ThreadLocalMap持有ThreadLocal的弱引用，即使没有手动删除，ThreadLocal也会被回收。value则在下一次ThreadLocalMap调用set,get，remove的时候会被清除。
因此可以发现，使用弱引用作为Entry的Key，可以多一层保障：弱引用ThreadLocal不会轻易内存泄漏，对应的value在下一次ThreadLocalMap调用set,get,remove的时候会被清除。
实际上，我们的内存泄漏的根本原因是，不再被使用的Entry，没有从线程的ThreadLocalMap中删除。一般删除不再使用的Entry有这两种方式：
  • 一种就是，使用完ThreadLocal，手动调用remove()，把Entry从ThreadLocalMap中删除
  • 另外一种方式就是：ThreadLocalMap的自动清除机制去清除过期Entry.（ThreadLocalMap的get(),set()时都会触发对过期Entry的清除）
7. InheritableThreadLocal保证父子线程间的共享数据
我们知道ThreadLocal是线程隔离的，如果我们希望父子线程共享数据，如何做到呢？可以使用InheritableThreadLocal。先来看看demo：
public class InheritableThreadLocalTest {   public static void main(String[] args) {       ThreadLocal threadLocal = new ThreadLocal<>();       InheritableThreadLocal inheritableThreadLocal = new InheritableThreadLocal<>();       threadLocal.set("关注公众号：捡田螺的小男孩");       inheritableThreadLocal.set("关注公众号：程序员田螺");       Thread thread = new Thread(()->{           System.out.println("ThreadLocal value " + threadLocal.get());           System.out.println("InheritableThreadLocal value " + inheritableThreadLocal.get());       });       thread.start();          }}//运行结果ThreadLocal value nullInheritableThreadLocal value 关注公众号：程序员田螺复制代码
可以发现，在子线程中，是可以获取到父线程的 InheritableThreadLocal 类型变量的值，但是不能获取到 ThreadLocal 类型变量的值。
获取不到ThreadLocal 类型的值，我们可以好理解，因为它是线程隔离的嘛。InheritableThreadLocal 是如何做到的呢？原理是什么呢？
在Thread类中，除了成员变量threadLocals之外，还有另一个成员变量：inheritableThreadLocals。它们两类型是一样的：
public class Thread implements Runnable {   ThreadLocalMap threadLocals = null;   ThreadLocalMap inheritableThreadLocals = null; }复制代码
Thread类的init方法中，有一段初始化设置：
 private void init(ThreadGroup g, Runnable target, String name,                      long stackSize, AccessControlContext acc,                      boolean inheritThreadLocals) {              ......        if (inheritThreadLocals && parent.inheritableThreadLocals != null)            this.inheritableThreadLocals =                ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);        /* Stash the specified stack size in case the VM cares */        this.stackSize = stackSize;        /* Set thread ID */        tid = nextThreadID();    } static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) {        return new ThreadLocalMap(parentMap);    }复制代码
可以发现，当parent的inheritableThreadLocals不为null时，就会将parent的inheritableThreadLocals，赋值给前线程的inheritableThreadLocals。说白了，就是如果当前线程的inheritableThreadLocals不为null，就从父线程哪里拷贝过来一个过来，类似于另外一个ThreadLocal，但是数据从父线程那里来的。有兴趣的小伙伴们可以在去研究研究源码~
8. ThreadLocal的应用场景和使用注意点
ThreadLocal的很重要一个注意点，就是使用完，要手动调用remove()。
而ThreadLocal的应用场景主要有以下这几种：
  • 使用日期工具类，当用到SimpleDateFormat，使用ThreadLocal保证线性安全
  • 全局存储用户信息（用户信息存入ThreadLocal，那么当前线程在任何地方需要时，都可以使用）
  • 保证同一个线程，获取的数据库连接Connection是同一个，使用ThreadLocal来解决线程安全的问题
  • 使用MDC保存日志信息。
参考与感谢
  • 彻底理解ThreadLocal
  • ThreadLocal是如何导致内存泄漏的
  • 深入分析 ThreadLocal 内存泄漏问题

作者：捡田螺的小男孩
链接：https://juejin.cn/post/7126708538440679460







展开阅读全文



页面更新：2024-05-10



标签：田螺   结构图   线程   变量   详解   场景   对象   内存   成员   代码   方法





1
2
3
4
5







	

		

		
		

		

			

			
想拯救地球？吃蘑菇和海藻中的蛋白质，而不是红肉

			

			

			想拯救地球？吃蘑菇和海藻中的蛋白质，而不是红肉“肉类替代品市场的销售额预计将从2020年的42亿美元大幅增长至2025年的280亿美元。”根据一项研究，仅用从真菌或藻类中提取的微生物蛋白质来代替我们所吃的五分之一的红肉，
			

		

	

	

		

		
		

		

			

			
联想集团研究报告：PC业务保持全球领先，服务器业务发展向好

			

			

			（报告出品方/作者：中信建投证券，金戈）一、公司系全球领先 ICT 企业1.1 公司系全球最大 PC 设备商联想集团成立于 1984 年，1994 年于港交所上市。公司以 PC 业务起家，1996 年成为国内 PC 品牌龙头，2005 年收购 IBM PC 业务，201
			

		

	

	

		

		
		

		

			

			
告别“烧钱”竞争，社区团购布局线下门店，行业格局趋于稳定

			

			

			在告别“烧钱”竞争，行业格局趋于稳定后，社区团购平台开始将重心放在提升经营效率与业务可持续发展上，并由此进行了一系列探索。在这个过程中，我们发现社区团购正在布局线下店。多位从业者认为，布局线下门店是社区团购平台
			

		

	

	

		

		
		

		

			

			
碳包铜！电催化CO₂RR最新Angew，超高乙醇电流密度和FE

			

			

			喜欢就关注我们吧，订阅更多最新消息第一作者：Yipeng Zang通讯作者：汪国雄，王琪通讯单位：中科院大连化学物理研究所，大连交通大学论文DOI：https://doi.org/10.1002/anie.202209629  全文速览对于将电还原CO2生成多种碳产物的
			

		

	

	

		

		
		

		

			

			
重磅报告揭秘汽车市场行情，新能源汽车竞争激烈

			

			

			7月30日，由全国工商联汽车经销商商会主办的“着眼新机遇、迎接新挑战、共谋新发展”主题会议在长沙顺利召开。车e估执行总裁范明崑作为受邀嘉宾出席会议，并在会议中解读2022上半年度汽车保值率报告，从多维角度全面剖析汽
			

		

	

	

		

		
		

		

			

			
激情不是心血来潮，也不是兴之所至，她更是一种觉悟、追求和境界

			

			

			风正好扬帆，激情就像是吹动船帆的风，可以让船儿在茫茫大海中自由徜徉。富有激情的人，人生一定很精彩。因为激情会获得源源不断的动力 ，因为激情会拥有巨大的正能量 ，她不仅让人工作学习出色，还能推动创新，创造不凡的业绩。在
			

		

	

	

		

		
		

		

			

			
摘抄

			

			

			   1.人处在一种默默奋斗的状态，精神就会从琐碎生活中得到升华 —路遥2.苦难既然把我推到了悬崖的边缘，那么就让我在这悬崖的边缘坐下来，顺便看着悬崖下的流岚雾霭，唱支歌给你听 —史铁生3.无论何人无论何时，人们总要在乌
			

		

	

	

		

		
		

		

			

			
合欢花

			

			

			   羽扇轻摇满枝红，落树粉蝶醉春梦。为爱一对搭花阴，殷勤扇送六月风。
			

		

	

	

		

		
		

		

			

			
那些只爱七分却写出了十分的惊艳文案，挑一句过七夕吧

			

			

			（特此声明，本文情话均由一空小师父原创，写给陈心如同学）1.曾经的我做过两个梦，一个是遇到你，一个是把自己锁在梦里。2.你是诗中的画，画中的诗，单是表达你的名字，便足够让我琢磨整个春天3.我把丝线揉成了一团，你说像我头发的形状
			

		

	

	

		

		
		

		

			

			
作文写不出优美的句子，就来看看

			

			

			1、从某种意义上说，世间一切，都是遇见。冷遇见暖，就有了丽：冬遇见春，有了岁月：天遇见地，有了水恒：人遇见人，有了生命。2、在这个世界上，没有一个人是孤岛：失去了陪伴，也失去了生存的意义3、生命不是你活了多少日子，而是你记住了多
			

		

	

	

		

		
		

		

			

			
夜读丨放慢脚步，等一等自己的灵魂

			

			

			。作者丨淡墨轩主播丨晓 峰美学大师蒋勋在《品味四讲》中写到：天地有大美而不言，美无处不在，我们要放缓节奏，感受生活中的点滴之美。大师相信，因为慢，才能更接近幸福。其实，我们又何尝没有亲身体会过，被快节奏的生活压得喘不
			

		

	

	

		

		
		

		

			

			
在太空制造虚拟恒星

			

			

			2016年4月26日，南美洲智利，在欧洲南方天文台旗下的帕拉纳天文台，4道激光光束划破宁静的夜空，在天空中造出了4颗明亮的人造星。这是一种叫做“4激光导星”的激光设备，它能向太空中发射4束激光，并创造出4颗虚拟小恒星。4激光
			

		

	

	

		

		
		

		

			

			
「科学频道」月球地壳的坑到底是什么？

			

			

			昨天，我陪家人看了近期上映的电影《独行月球》。电影《独行月球》海报大家都看到了，影片中，有很多陨石撞击月球表面的镜头。 陨石正在撞向月球那月球表面形成的大坑是怎么形成的呢？月球表面大约44亿年前，早期的太阳系就像
			

		

	

	

		

		
		

		

			

			
地球比平时旋转得更快 科学家们记录了有史以来最短的一天

			

			

			据91Mobiles报道，我们并没有真正特别注意时间是如何运作的--并假定它是一个稳定的进程，由地球围绕其自转轴旋转和围绕太阳的旋转来定义。然而，我们的星球并不是什么都是统一的，就像地球最近一次创纪录的绕自转轴旋转所看
			

		

	

	

		

		
		

		

			

			
「科学频道」人类登月到底是不是真的？

			

			

			 近日，我看了开心麻花拍摄的电影《独行月球》，内容很搞笑，也很有意思，很多画面和场景展现得都很好，科学元素很多，道具方面科技感很强、很细致。例如，宇航服、空间站、月球车等等，都很不错。电影《独行月球》海报迄今为止，尽管5
			

		

	


上滑加载更多 ↓






	

	
推荐阅读：


	

		

			

			
暑假换机购机先别急，看看这几款大内存新机

			

		

	


	

		

			

			
手机存储不够用？速来查收你的大内存新机购机攻略

			

		

	


	

		

			

			
西瓜吃不完不要放冰箱，教你一个土方法保存几天，跟新鲜的

			

		

	


	

		

			

			
点亮DDR5“性能之路”：美商海盗船发布复仇者RGB DDR5内

			

		

	


	

		

			

			
12+256G大内存，但售价才两千元，这三款手机每款都性价比

			

		

	


	

		

			

			
LINE打不开、频频闪退怎么办？5个方法帮你解决问题

			

		

	


	

		

			

			
创新腰椎疾病治疗方法，为孕妈妈除病痛→

			

		

	


	

		

			

			
化疗后，头发逐渐脱落，怎么办？脱发也有治疗方法

			

		

	


	

		

			

			
癫痫的护理方法有哪些

			

		

	


	

		

			

			
一种专用于SMC增稠的表面改性纳米氧化镁材料的制备方

			

		

	


	

	
	

	
友情链接：

	

		
	

	


	

	
更多：

	

		
本站资料均由网友自行发布提供，仅用于学习交流。如有版权问题，请与我联系，QQ：4156828  

		
© CopyRight 2008-2024 All Rights Reserved. Powered By bs178.com  闽ICP备11008920号-3
闽公网安备35020302034844号

	

	

	




Top