Java并发——从线程到同步

文章目录

• • • 并发1
    • • 基础概念
      • 什么是线程
      • 线程状态
      • 线程属性
      • 同步

并发1

基础概念

1. 多任务：模拟同时进行多个任务，实质上在一个时间点只做一个任务
2. 多线程：多个任务交叉进行
3. 线程：独立的执行路径
4. 进程和线程的区别：进程拥有自己的一整套变量，线程则共享数据。

什么是线程

1. 构造一个简单线程

   Thread(Runnable target)

   构造一个新线程，调用指定目标的run()方法

   1. 创建一个Runnable的变量并实现run()方法
   2. 继承Thread类，并实现run()方法

2. void start()启动一个线程，从而调用run()方法。这个方法会立即返回，新线程会并发运行。

   不要调用Thread类或Runnable对象的run方法

3. static void sleep(long millis)，休眠指定的毫秒数，用于模拟网络延时

线程状态

1. New新建线程new Thread(r)这个线程还没有开始运行

2. Runnable可运行线程：一旦调用了start方法，线程就处于可运行状态。

   static void yield()

   线程礼让，使线程从运行状态转变为可运行状态开始就绪，重新与其他程序竞争。

3. Blocked & Waiting 阻塞和等待线程：此状态的线程暂时不活动，由线程调度器重新激活这个线程

   1. 当一个线程试图获取一个内部的对象锁， 而这个锁目前被其他线程占有，该线程就会被阻塞。
   2. 当线程等待另一个线程通知调度器出现一个条件时，这个线程就会进入等待状态。
   3. 主动进入阻塞和等待状态：计时等待：Object.wait、Thread.join、Lock.tryLock、Condition.await

4. 终止线程

   1. run方法正常退出，线程自然终止
   2. 异常终止

   推荐让线程自己停止：不建议死循环

   建议使用一个标志位进行终止程序

   void join()

   void join(long millis)

   等待终止指定程序，使线程插队，为了使线程提前

   Thread.State.getState()

   得到这个线程的状态

   

线程属性

1. 中断线程（不推荐使用）

   1. void interrupt()用于发送中断请求，如果当前线程被一个sleep调用阻塞，则抛出一个InterruptedException异常
   2. static boolean interrupted()，测试当前线程是否被中断，并会清除中断状态
   3. boolean isInterrupted(), 与前一个方法相比，不会清除中断状态
   4. static Thread currentThread(),返回一个正在执行的线程。

2. 守护线程

   void setDaemon(boolean isDaemon)

   标识该线程为守护线程或者用户线程，必须在线程启动之前调用

   守护线程：虚拟机不用等待守护线程执行完毕，即可退出，gcc垃圾清理线程

   用户线程：虚拟机需要等待守护线程执行完毕，才可退出，main函数

3. 线程名

   public Thread(Runnable target, String name)
   

   或者

   new Thread(Runnable target).setName(String)

4. 未捕获异常处理器

   1. 构造处理器，必须属于一个实现了Thread.UncaughtExceptionHandler接口的类，这个接口只有一个方法

      void uncaughtException(Thread t, Throwable e)

   2. 为线程设置处理器

      使用setUncaughtExceptionHandler静态方法，默认处理器为ThreadGroup对象

5. 线程的优先级

   10个优先级， MIN_PRIORITY(1), NORM_PRIORITY(5),MAX_PRIORITY(10)

   void setPriority(int new Priority)

同步

并发：同一个对象被多个线程同时操作

同步的条件：队列 + 锁

1. 竞态条件详解

   多个线程对同一个对象进行操作，存在操作不是原子操作，前一个线程任务还没执行完全，运行权被另一个线程抢占，后一个程序执行完后，交还运行权，前一个线程的操作即将覆盖掉前一个线程的操作

2. 锁对象ReentrantLock类(用于保护代码片段)

   1. 构造一个重入锁，来保护临界区， 锁是对于当前对象来说的。

      var lock = new ReentrantLock()

   2. 获得锁

      lock.lock()

      获得这个锁，如果锁当前被另一个线程占有，则阻塞

   3. 释放锁

      lock.unlock()

   var myLock = new ReentrantLock();
   myLock.lock();
   try {
       critical section
   } finally {
       mylock.unlock();
   }
   

3. 条件对象（生产者和消费者问题）

   1. 创建条件对象

   Condition newCondition()

   返回一个与这个锁相关联的条件对象

   2. 条件等待 Condition对象调用

      void await()

      将该线程放在这个条件的等待集中，并放弃锁

   3. 解除条件等待

      void signalAll()

      解除该条件等待集中所有线程的阻塞状态

      void signal()

      从该条件的等待集中随机选择一个线程，解除其阻塞状态

   private Condition condition;
   private var myLock = new ReentrantLock();
   void func() {
   	myLock.lock();
   	try {
   		while(!(OK to proceed)) condition.await();
   		...
   		Maight be good to proceed
   		condition.signalAll();
   	}
   }
   

4. synchronized关键字：默认锁本对象

   public synchronized void method() {
   	method body
   }
   

   Object类中含有内部锁，其中方法有

   void notifyAll()，只在同步方法和同步快有效

   void notify()

   类似于上面的sigalAll()、signal()

   void wait()| void wait(long millis)

5. 同步块

   sychronized(obj) {
   	critical section
   }
   

   它会获得obj的锁

6. volatile字段: 为实例字段的同步访问提供了一种免锁机制

7. 原子性atomic包

   AuomicLong类型变量

   long incrementAndGet(),以原子方式自增，并返回自增后的值

   void updateAndGet()

   void accumulateAndGet(observed, Math::max);

8. 死锁：多个线程各自占有一些资源的同时，需要其他资源，而其他资源被对方占据，不解锁，从而进入死循环。

9. 线程局部变量ThreadLocal<T>

   var threadLocal = ThreadLocal.withInitial(Supplier <? extends S> suplier);

   创建一个线程局部变量，其初始值通过调用给定的提供者生成

   T get()

   得到这个线程的当前值

   void Set(T t)

   为这个线程设置一个新值

   void remove()

   删除对应这个线程的值