/   今日科技快讯   /

近日发布的《2021年企业年终奖发放计划调研报告》显示，2021年年终奖的人均水平为2.3万元， 2021年企业年终奖额度相当于员工2.1倍月薪。41%的企业表示2021年年终奖额度有所提升，31%的企业年终奖额度和2020年持平，企业年终奖提升额度大多在10%以内。从行业来看，金融行业2021年终奖平均水平为4.52万元，领跑各行业；高科技行业相比去年上涨11%，涨幅高居各行业之首。

/   作者简介   /

本篇文章来自android超级兵的投稿，文章主要分享了他所整理的线程相关的知识，相信会对大家有所帮助！同时也感谢作者贡献的精彩文章。

android超级兵的博客地址：

https://blog.csdn.net/weixin_44819566

/   正文   /

常见创建线程的几种方式

方式一

方式二

方式三

方式一，方式二和方式三的启动代码：

public static void main(String[] args) throws ExecutionException, InterruptedException {// 方式一MyThread myThread = new MyThread();myThread.start();// 方式二MyRunnable myRunnable = new MyRunnable();new Thread(myRunnable).start();// 方式三MyCallable myCallable = new MyCallable();FutureTask<String> futureTask = new FutureTask<String>(myCallable) {@Overrideprotected void done() {System.out.println("方式三开始前!");super.done();System.out.println("方式三执行后!");try {System.out.println("done内部获取方式三返回结果:" + get());} catch (InterruptedException e) {e.printStackTrace();} catch (ExecutionException e) {e.printStackTrace();}}};// 方式三启动线程new Thread(futureTask).start();System.out.println("获取方式三返回结果:" + futureTask.get());
}

运行结果：

三种方式的区别：

• extend Thread 需要手动重写run方法

• implements Runnable 需要将当前runnable对象传入Thread中

• implements Callable<*> 可以获取到thread的返回值，并且不能直接传给thread启动，需要采用FutureTask来配合，并且可以通过FutureTask.get()获取到实现 implements Callable的<*>的call的返回值

Thread.start() 和 Thread.run() 的区别

再来看一段代码。

start

Client4Thread client4Thread = new Client4Thread();
client4Thread.start();

运行结果：

thread:Thread-0

run

Client4Thread client4Thread = new Client4Thread();
client4Thread.run();

运行结果：

thread:main

结论

如果调用Thread.run()方法相当于一个普通类调用了一个run方法，并没有开启子线程。相当于这样：

public static class User {public void run() {System.out.println("User.run" + Thread.currentThread().getName());}}

client4Thread.run()等价于User.run()！

Client4Thread client4Thread = new Client4Thread();
//        client4Thread.start();// 效果一样
client4Thread.run();
//
//
new User().run();

Thread.join() 线程串形化

先来看使用场景：

现在有三个线程，同时运行，先来运行看看结果：

可以看出，每次执行顺序都不同…如果你想让他同步执行，你可以这样做。

结论

join的作用就是将线程串行化，需要注意的是，join()一定要放在现场开启(start())后。

Thread.Interrupt()线程中断

运行代码：

运行结果为：

可以看出，虽然向子线程发送了中断信号，但是线程并不会执行终端，而是一直存活着。如果想要线程中断，只需要在Thread中判断一下isInterrupted()即可。例如这样：

运行结果为：

小坑

如果你需要在！isInterrupted()中休眠一下，例如这样：

这样是不可以的，因为Thread.sleep会捕获中断信号，并且将中断信号改为false。最终导致结果成这样了。

最终就会导致捕获到了中断异常，但是Thread.sleep()擅自更改了...只需要在捕获到InterruptedException异常的时候，再次更改状态即可。例如这样：

当然不仅是extend Thread这种写法可以中断线程，implements Runnable当前也可以中断线程，比如这样写：

效果是一样的，就不重复展示了…

Thread 数据共享 synchronized(隐式锁)

还是先来看简单的案例。现在有2个线程，需要同时对count ++，例如这样:

结果为：

可以看出，每次运行的结果都不一样？这是为什么？因为这里是循环添加1000 * 100次，在2个线程同时跑的时候，就会出现两个count同时执行的情况，所以导致数字总是不太对。这里只需要让他同步起来(添加同步锁)即可，例如这样：

常见锁的写法

锁某一个类的class。

private static final Object object = new Object();public static void addCount() {for (int i = 0; i < countLength; i++) {synchronized (object) {count++;}}
}

锁当前对象的this。

public synchronized void addCount2() {.....
}

锁指定对象的class。

public static void addCount() {for (int i = 0; i < countLength; i++) {synchronized (Client2.class) {count++;}}}

Thread线程隔离(ThreadLocal)

什么是线程隔离，还是先看代码：

还是先来看结果：

可以看出，每一次的运行效果都是不一样的这是因为启动(start)的时候，线程只是就绪状态，只是通知JVM我可以执行了，真正的执行是JVM来调用的。以最后一次结果来看问题：

ThreadName:Thread-1    threadIndex:1   count:2
ThreadName:Thread-4    threadIndex:4   count:11
ThreadName:Thread-3    threadIndex:3   count:7
ThreadName:Thread-2    threadIndex:2   count:4
ThreadName:Thread-0    threadIndex:0   count:2

先来分析一下代码：main方法中，开启了5个线程，并且将下标传了进去，然后再MyThreadLocal具体对下表累加。

需求分析

既然说到是线程隔离，那么想要的效果应该是假如现在传入进来的是5，那么通过。

count+=threadIndex;

应该结果是6，而不应该吧其他线程的结果也算到当前线程头上这段话说的比较绕，直接来看ThreadLocal就明白了！

启动的时候添加了一个Thread.join()使线程顺序执行…

直接看效果：

可以看出，现在就实现了线程的隔离。如果你阅读过Handler源码，也会发现他内部使用了ThreadLocal来进行线程隔离。不过这里线程隔离隔离的是Lopper，为了保证一个线程只有一个looper。瞟一眼handler的代码：

显示锁

可重入锁 (ReentrantLock)

什么是可重入？

int count = 0;
public synchronized void test() {count++;if (count <= 10) {test();}}

先拿synchronized来举例，以当前的认知来看，如果递归情况下，synchronized一定会被锁死，因为第一次执行test()的时候，还没有释放锁就进行了第二次的加锁。但是从结果来看，毫无问题，因为synchronized是具有可重入性的，可重入就是指如果同一个实例的话，可重新进入。ReentrantLock也是同样的道理，来看看ReentrantLock的使用：

结果还是那个结果：

这里需要注意的是，在使用隐式锁的时候，一定要放在try { ... } finally { .. }代码块中。这样做是因为即使抛出异常，也会吧锁释放掉，不会出现死锁情况。规范示例：

lock.lock();
try{count++;
} finally {lock.unlock();
}

读写锁 (ReentrantReadWriteLock)

要想突出ReentrantReadWriteLock的效果，那就必须有对比，这里就和synchronized来比较！

思路

开启3个写线程，30个读线程，来模拟实际开发中的读取操作。通过同步锁(synchronized)和读写锁的实际效果来看他们的运行机制！再来看代码思路。

StudentImpl

getThread

setThread

运行

可以看出，效果是十分的明显，从变化中也可以看出，如果要进行大量的读写操作，使用读写锁效率会大大的提高！

课外知识 volatile!

volatile本不属于Thread的知识，但是既然说到这么多关键字，那就提一嘴吧！还是一段代码引出区别。

未加volatile关键字

效果图：

可以看出，不加volatile关键字isRun，即使是改变了，线程中也是没反应，接受不到…再来看看添加volatile关键字：

效果图：

结果显而易见，一旦标记了volatile isRun变量，只要发生改变就回直接通知JVM来改变当前的状态！！

完整代码地址：

https://gitee.com/lanyangyangzzz/thread-project

推荐阅读：

我的新书，《第一行代码 第3版》已出版！

在微软工作365天，还你一个我眼中更加真实的微软

Jetpack全家桶中最受欢迎的一定是它

欢迎关注我的公众号

学习技术或投稿

长按上图，识别图中二维码即可关注