一、新起线程方式
1.new Thread
object : Thread() {
override fun run() {
Log.i(TAG, "thread1=" + Thread.currentThread().name)
}
}.start()
2.Runnable
Thread { Log.i(TAG, "thread2=" + Thread.currentThread().name) }.start()
Thread(Runnable { Log.i(TAG, "thread3=" + Thread.currentThread().name) }).start()
3.线程池的使用(Executor)
var executor = Executors.newCachedThreadPool();
executor.execute { Log.i(TAG, "thread4=" + Thread.currentThread().name) }
executor.execute { Log.i(TAG, "thread5=" + Thread.currentThread().name) }
executor.execute { Log.i(TAG, "thread6=" + Thread.currentThread().name) }
线程池的优点:
1.重用线程池中的线程,避免因为线程创建和销毁所带来的性能开销
2.能有效控制线程池的最大并发数,避免大量的线程之间因互相抢占系统资源而导致的阻塞现象
3.能够对线程进行简单管理
线程池的种类:
newCachedThreadPool
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue());
}
1.没有核心线程,只有非核心线程
2.最大线程数可以任意大
3.空闲线程有60s超时处理
4.适合处理大量的耗时较少的任务
newSingleThreadExecutor
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue()));
}
1.只有1个核心线程
2.不需要处理线程同步问题
ScheduledThreadPoolExecutor
public ScheduledThreadPoolExecutor(int corePoolSize) {
super(corePoolSize, Integer.MAX_VALUE,
DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
new DelayedWorkQueue());
}
1.核心线程数是固定的,非核心线程数没有限制
2.非核心线程限制的时候会被立即回收
3.适合执行定时任务和具有固定周期的重复任务
newFixedThreadPool
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue());
}
1.只有核心线程数,并且没有超时时间
2.更快响应
二、线程同步
谈对synchronized的理解
作用:对资源同步,对数据同步
使用方法:
在方法名前添加
@Synchronized fun count(){}
@Synchronized fun add(){}
所有在方法前添加Synchronized的方法,都会默认添加了同一个monitor,
这样子只要有一个方法被访问而且没有执行完,
其他添加Synchronized的也同样不可以访问
eg:
当访问count方法的时候,只要方法没有执行完毕,add方法也不会被访问
以代码块的形式添加添加到方法中
fun count() {
synchronized(this) {
}
}
代码块可以控制monitor类型,使得有相关关系的方法才有同步关系
什么是原子性
一次性可执行完,中途不会中断
volatile是什么
轻量的,使得具有原子性和同步性,但是只可用于基本数据类型
Atomic~是干啥的
用于i++ 使得其同步,
因为i++ 可以拆成两步 a=i+1 i=a
死锁怎么回事
存在多个锁的情况,你等我,我等你
class DeadLock {
Object o1 = new Object();
Object o2 = new Object();
void m1(){
synchronized(o1){
System.out.println("m1 Lock o1 first");
synchronized(o2){
System.out.println("m1 Lock o2 second");
}
}
}
void m2(){
synchronized(o2){
System.out.println("m2 Lock o2 first");
synchronized(o1){
System.out.println("m2 Lock o1 second");
}
}
}
}
m1的等待o2执行完,m2的等待o1执行完
乐观锁
拿到数据后,在往回写的时候检查数据跟最开始拿的是否一致,不一致再重新拿重新计算
悲观锁
拿到数据后,就锁上了,不让其他来更改,知道他改完后其他才可以操作
欢迎批评指正
~~喵印