874

Posted 2020-11-09 buder

1.looper.prepare()做了啥操作
https://www.cnblogs.com/ganchuanpu/p/5979103.html
2.looper如何知道当前线程是哪个线程
https://blog.csdn.net/adobesolo/article/details/75195394
3.为啥looper.loop死循环不会造成ANR
https://www.zhihu.com/question/34652589
4.asynctask缺点总结
https://blog.csdn.net/goodlixueyong/article/details/45895997
5.正确结束AsyncTask任务编码
第一步：
https://blog.csdn.net/chenleicpp/article/details/45363723
第二步：
https://www.cnblogs.com/xqxacm/p/5227159.html
https://www.cnblogs.com/hxb2016/p/6143648.html
第一步：在合适的地方将task cancel掉
@Override
protected void onPause() {
// TODO Auto-generated method stub
super.onPause();
if(myTask != null && myTask.getStatus() == AsyncTask.Status.RUNNING){
myTask.cancel(true);
}
}
第二步：判断标志位，return掉
public void onProgressUpdate(Integer... value) {
// 判断是否被取消
if(isCancelled()) return;
.........
}

@Override
protected Integer doInBackground(Void... mgs) {
// Task被取消了，马上退出
if(isCancelled()) return null;

6.Java中如何正确而优雅的终止运行中的线程
https://blog.csdn.net/zhangliangzi/article/details/52484302
https://www.cnblogs.com/luckygxf/p/4737655.html
https://www.baidu.com/link?url=GfRFcHoDchCGf7au8EwY5q3LbIYnZYitHIhvnF02yNOdrvp4fWIXWvDST29RLiwoBh3bUy7-BfknD8k5BzExK_&wd=&eqid=b7b8ee5900012926000000065b0923c7
第一种方法：使用volatile标志位使用volatile标志位
第二种方法：
thread1.interrupt();
thread2.interrupt();
thread3.interrupt();
try {
Thread.sleep(1000L);
} catch (InterruptedException e) { //阻塞的话会抛出异常
e.printStackTrace();
}
//运行时的线程被中断后，只会修改中断标记，不会抛出异常
while(Thread.currentThread().isInterrupted()){
第三种方法：stop强行停止不好

7.join的理解：
https://www.cnblogs.com/lcplcpjava/p/6896904.html
自己理解：
线程2要等线程1执行完后执行，写法:
t1.start();
t1.join();
t2.start();

线程3要等线程1,2执行完之后执行，写法：
worker1.start();
worker2.start();

worker1.join();
worker2.join();

worker3.start();

7.控制线程的执行顺序：使用CountDownLatch来控制并发
https://www.cnblogs.com/flyme/p/4568063.html
初始化一个countdown值为2
CountDownLatch mCountDownLatch = new CountDownLatch(2);
如果当前线程需要等待其他线程执行完了之后再往下面走，则在当前线程中使用：
mCountDownLatch.await();进行等待操作
在其他线程中进行：
mCountDownLatch.countDown();每次减1，直到mCountDownLatch变为0，则等待线程往下执行
https://blog.csdn.net/answer100answer/article/details/77658097
CountDownLatch需要开发人员很明确需要等待的条件，否则很容易造成await()方法一直阻塞的情况。

9.CountDownLatch理解一：与join的区别
https://blog.csdn.net/zhutulang/article/details/48504487

countdown可以在线程某一步完成后countdown 1，然后在await线程可以往后执行；
而join必须等线程执行完毕后，才会往后执行

10.CyclicBarrier和CountDownLatch的区别
http://www.jb51.net/article/119064.htm
CountDownLatch和CyclicBarrier都能够实现线程之间的等待，只不过它们侧重点不同：

CountDownLatch一般用于某个线程A等待若干个其他线程执行完任务之后，它才执行；

而CyclicBarrier一般用于一组线程互相等待至某个状态，然后这一组线程再同时执行；

11.AQS共享模式
https://www.cnblogs.com/lfls/p/7599863.html
跟独占锁相比，共享锁的主要特征在于当一个在等待队列中的共享节点成功获取到锁以后（它获取到的是共享锁），既然是共享，那它必须要依次唤醒后面所有可以跟它一起共享当前锁资源的节点
http://www.cnblogs.com/lfls/p/7598380.html
就是尝试去获取锁，如果失败就加入一个队列中挂起。释放锁时，如果队列中有等待的线程就进行唤醒。

12.不可重入锁
https://www.jianshu.com/p/007bd7029faf

可重入锁：
可重入就意味着：线程可以进入任何一个它已经拥有的锁所同步着的代码块
https://www.cnblogs.com/dj3839/p/6580765.html

13.？？
synchronized 与 lock 区别
https://blog.csdn.net/wu1226419614/article/details/73740899

虽然Lock缺少了synchronized隐式获取释放锁的便捷性，但是却拥有了锁获取与是释放的可操作性、可中断的获取锁以及超时获取锁等多种synchronized所不具备的同步特性;

两个例子超级清晰理解：
synchronized lock 区别 waitnotify 以及控制线程执行顺序
https://www.cnblogs.com/benshan/p/3551987.html

14.ReentrentLock对象和ReentrentReadWriteLock为我们日常开发中见到和用到比较多的两个类；他们都是可重入的锁，即当同一线程获取到锁之后，他在不释放锁的情况下，可以再次获取到当前已经拿到的锁，只需标记获取到锁的次数加一即可

15.上述各种锁机制的总结文章！！！
https://www.cnblogs.com/baizhanshi/p/6419268.html
他俩的区别：
（1）那么如果这个获取锁的线程由于要等待IO或者其他原因（比如调用sleep方法）被阻塞了，但是又没有释放锁，其他线程便只能干巴巴地等待，试想一下，这多么影响程序执行效率。
（2）当有多个线程读写文件时，读操作和写操作会发生冲突现象，写操作和写操作会发生冲突现象，但是读操作和读操作不会发生冲突现象。
使用方式：
第一种：
Lock lock = ...;
lock.lock();
try{
//处理任务
}catch(Exception ex){

}finally{
lock.unlock(); //释放锁
}
第二种：
Lock lock = ...;
if(lock.tryLock()) {
try{
//处理任务
}catch(Exception ex){

}finally{
lock.unlock(); //释放锁
}
}else {
//如果不能获取锁，则直接做其他事情
}
ReadWriteLock也是一个接口
而由于synchronized和Lock都具备可重入性
读写锁将对一个资源（比如文件）的访问分成了2个锁，一个读锁和一个写锁。

正因为有了读写锁，才使得多个线程之间的读操作不会发生冲突。
ReadWriteLock就是读写锁，它是一个接口，ReentrantReadWriteLock实现了这个接口。
可以通过readLock()获取读锁，通过writeLock()获取写锁。
垃圾文章：
https://www.cnblogs.com/benshan/p/3551987.html
https://blog.csdn.net/wu1226419614/article/details/73740899

16.线程安全的CopyOnWriteArrayList介绍
https://blog.csdn.net/linsongbin1/article/details/54581787
CopyOnWrite的缺点：
1.由于写操作的时候，需要拷贝数组，会消耗内存，尤其是原数组的内容比较多的情况下；因为谁也没法保证CopyOnWriteArrayList到底要放置多少数据，万一数据稍微有点多，每次add/set都要重新复制数组，这个代价实在太高昂了。在高性能的互联网应用中，这种操作分分钟引起故障
2.不能用于实时读的场景，像拷贝数组、新增元素都需要时间，所以调用一个set操作后，读取到数据可能还是旧的,虽然CopyOnWriteArrayList 能做到最终一致性,但是还是没法满足实时性要求

17.ArrayList实现线程安全
一：使用synchronized关键字，这个大家应该都很熟悉了，不解释了；

二：使用Collections.synchronizedList()

三：使用CopyOnWriteArrayList

18.Collections.synchronizedList & CopyOnWriteArrayList对比
CopyOnWriteArrayList和Collections.synchronizedList是实现线程安全的列表的两种方式。两种实现方式分别针对不同情况有不同的性能表现，其中CopyOnWriteArrayList的写操作性能较差，而多线程的读操作性能较好。而Collections.synchronizedList的写操作性能比CopyOnWriteArrayList在多线程操作的情况下要好很多，而读操作因为是采用了synchronized关键字的方式，其读操作性能并不如CopyOnWriteArrayList。因此在不同的应用场景下，应该选择不同的多线程安全实现类
好的文章；
https://blog.csdn.net/yangzl2008/article/details/39456817
结论：
CopyOnWriteArrayList，发生修改时候做copy，新老版本分离，保证读的高性能，适用于以读为主，读操作远远大于写操作的场景中使用，比如缓存。而Collections.synchronizedList则可以用在CopyOnWriteArrayList不适用，但是有需要同步列表的地方，读写操作都比较均匀的地方

19.Java多线程之同步集合和并发集合
同步集合类：
Hashtable
Vector
同步集合包装类，Collections.synchronizedMap()和Collections.synchronizedList()

并发集合类：
ConcurrentHashMap
CopyOnWriteArrayList
CopyOnWriteHashSet