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執行完

樂觀鎖

拿到數據後，在往回寫的時候檢查數據跟最開始拿的是否一致，不一致再重新拿重新計算

悲觀鎖

拿到數據後，就鎖上了，不讓其他來更改，知道他改完後其他纔可以操作

歡迎批評指正
～～喵印