Android 多线程以及线程同步相关

一、新起线程方式

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<Runnable>());
    }
1.没有核心线程，只有非核心线程
2.最大线程数可以任意大
3.空闲线程有60s超时处理
4.适合处理大量的耗时较少的任务

newSingleThreadExecutor

public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }
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<Runnable>());
    }
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执行完

乐观锁

拿到数据后，在往回写的时候检查数据跟最开始拿的是否一致，不一致再重新拿重新计算

悲观锁

拿到数据后，就锁上了，不让其他来更改，知道他改完后其他才可以操作

欢迎批评指正
～～喵印