Java并发编程实战笔记 （二）多线程安全程序开发

一、线程

 1. 线程和进程的关系

根本区别：进程是操作系统资源分配的基本单位，而线程是处理器任务调度和执行的基本单位

资源开销：每个进程都有独立的代码和数据空间（程序上下文），程序之间的切换会有较大的开销；线程可以看做轻量级的进程，同一类线程共享代码和数据空间，每个线程都有自己独立的运行栈和程序计数器（PC），线程之间切换的开销小。

包含关系：如果一个进程内有多个线程，则执行过程不是一条线的，而是多条线（线程）共同完成的；线程是进程的一部分，所以线程也被称为轻权进程或者轻量级进程。

内存分配：同一进程的线程共享本进程的地址空间和资源，而进程之间的地址空间和资源是相互独立的

 多个线程共享进程的堆和方法区 (JDK1.8 之后的元空间)资源，但是每个线程有自己的程序计数器、虚拟机栈 和 本地方法栈。

程序计数器、虚拟机栈 和 本地方法栈保存的是一个 程序进行的切面 保存了局部变量、程序运行位置等 ，方便线程暂停后重新继续调用。

影响关系：一个进程崩溃后，在保护模式下不会对其他进程产生影响，但是一个线程崩溃整个进程都死掉。所以多进程要比多线程健壮。

执行过程：每个独立的进程有程序运行的入口. 顺序执行序列和程序出口。但是线程不能独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制，两者均可并发执行

2.线程的生命周期及五种基本状态

来自《并发编程的艺术》 

• NEW: 初始状态，线程被创建出来但没有被调用 start() 。
• RUNNABLE: 运行状态，线程被调用了 start()等待运行的状态。
• BLOCKED ：阻塞状态，需要等待锁释放。
• WAITING：等待状态，表示该线程需要等待其他线程做出一些特定动作（通知或中断）。
• TIME_WAITING：超时等待状态，可以在指定的时间后自行返回而不是像 WAITING 那样一直等待。
• TERMINATED：终止状态，表示该线程已经运行完毕。

 3. 线程的操作

   1）创建和启动线程线程

         1.   创建 Thread 的子类并重写 run()

public class MyThread extends Thread {
    @Override
    public void run(){
        System.out.println("MyThread running");
    }
}

         run() 方在调用 start() 方法后被执行，而且一旦线程启动后 start() 方法后就会立即返回，而不是等到 run() 方法执行完毕后再返回。如果直接运行run()方法,并不会直接创建线程，而是在主线程中运行run（）方法。

         2. 实现 Runnable 接口

public class MyRunnable implements Runnable{
    @Override
    public void run(){
        System.out.println("MyRunnable running");
    }
}

        在新建类时实现 Runnable 接口，然后在 Thread 类的构造函数中传入 MyRunnable 的实例对象，最后执行 start() 方法即可； 

        3. 使用线程池

        线程池提供了一种限制和管理资源（包括执行一个任务）。 每个线程池还维护一些基本统计信息，例如已完成任务的数量。

使用线程池的好处：

• 降低资源消耗。 通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
• 提高响应速度。 当任务到达时，任务可以不需要的等到线程创建就能立即执行。
• 提高线程的可管理性。 线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

线程池的任务处理实现方法：

public interface Executor {
    void execute(Runnable command);
}

        由java.util.concurrent提供的线程池实现，为灵活的异步任务执行框架提供了基础并且基于生产者——消费者模式。

线程池类型：

来自 java并发编程实战

 生命周期：

Executor 拓展了ExecutorService来管理生命周期，支持关闭、终止等操作。

ExecutorService的生命周期包含了:运行、关闭、已终止

public interface ExecutorService extends Executor {
    void shutdown();
    List<Runnable> shutdownNow();


    boolean isShutdown();


    boolean isTerminated();


    <T> Future<T> submit(Callable<T> task);

    <T> Future<T> submit(Runnable task, T result);

    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
        throws InterruptedException;

    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                                  long timeout, TimeUnit unit)
        throws InterruptedException;

    <T> T invokeAny(Collection<? extends Callable<T>> tasks)
        throws InterruptedException, ExecutionException;


    <T> T invokeAny(Collection<? extends Callable<T>> tasks,
                    long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

线程的执行 ：

 1）通过excute（） 执行不需要返回值的线程任务

 2)使用callable和Future 执行获取返回值的线程任务

Callable和future：

public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

public interface Future<V> {

    boolean cancel(boolean mayInterruptIfRunning);

 
    boolean isCancelled();
    boolean isDone();
    V get() throws InterruptedException, ExecutionException;
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

   使用方法：

        在executor中调用submit提交callable会返回一个描述任务执行情况的Future

 * class App {
 *   ExecutorService executor = ...
 *   ArchiveSearcher searcher = ...
 *   void showSearch(final String target)
 *       throws InterruptedException {
 *     Future<String> future
 *       = executor.submit(new Callable<String>() {
 *         public String call() {
 *             return searcher.search(target);
 *         }});
 *     displayOtherThings(); // do other things while searching
 *     try {
 *       displayText(future.get()); // use future
 *     } catch (ExecutionException ex) { cleanup(); return; }
 *   }
 * }}

但这种方法需要反复的使用get方法，通过轮询来获取任务是否完成。以下实现是一种更好的方式。即使用完成服务，融合executor 和 BlokingQueue功能的CompletionService。

 2. 取消线程       

一般我们采用线程中断的方式来实现取消和关闭线程。

        中断操作：并不会真正的中断一个正在运行的线程，而只是发出中断请求。

        退出线程：

        1. 线程自主运行结束

        2. 外部·执行任务取消操作，线程应能可取消， 比如采用Thread.stop() 或 suspend等这些方法但存在严重缺陷。或抛出异常的方式
        

Thread 调用检查程序中断的方法

线程中可采用Thread.currentThread().isInterrupted()判断当前线程是否中断；

        3. 通过future来实现取消

        调用 future.cancel（）方法。

        4. 关闭ExecutorService

        shutdown、shutdownNow 两个方法

•   shutdown（） :关闭线程池，线程池的状态变为 SHUTDOWN。线程池不再接受新任务了，但是队列里的任务得执行完毕。
•  shutdownNow（） :关闭线程池，线程的状态变为 STOP。线程池会终止当前正在运行的任务，并停止处理排队的任务并返回正在等待执行的 List。 shutdownNow的原理是遍历线程池中的工作线程，然后逐个调用线程的interrupt方法来中断线程，所以无法响应中断的任务可能永远无法终

3. 线程的等待方法

当线程执行 wait()方法之后，线程进入 WAITING（等待） 状态。进入等待状态的线程需要依靠其他线程的通知才能够返回到运行状态。

超时等待：TIMED_WAITING(超时等待) 状态相当于在等待状态的基础上增加了超时限制，比如通过 sleep（long millis）方法或 wait（long millis）方法可以将线程置于 TIMED_WAITING 状态。当超时时间结束后，线程将会返回到 RUNNABLE 状态。

 

Thread.join()：

        Thread中的join方法主要的作用是让jion的线程加入当前线程，等加入的线程执行完之后才会执行当前线程。

public class TestJoin {
 
    public static void main(String[] args) throws InterruptedException {
 
 
 
        Thread t1 = new Thread(() ->
        {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("this is t1");
        });
 
        Thread t2 = new Thread(() -> {
 
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("this is t2");
        });
 
 
        Thread t3 = new Thread(() -> {
            System.out.println("this is t3");
        });
 
        t1.start();
        t2.start();
        t3.start();
        t1.join();
        t2.join();
        t3.join();
        System.out.println("运行结束");
    }
 
}

 object.wait() 和 Thread.sleep()的使用方法

new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程A等待获取lock锁");
                synchronized (lock) {
                    try {
                        System.out.println("线程A获取了lock锁");
                        Thread.sleep(1000);
                        System.out.println("线程A将要运行lock.wait()方法进行等待");
                        lock.wait();
                        System.out.println("线程A等待结束");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();

————————————————
版权声明：本文为CSDN博主「DivineH」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_38293564/article/details/80432875

Object.wait() 是让获得对象锁的线程实现等待，会自动释放当前线程占有的对象锁。每个对象（Object）都拥有对象锁，既然要释放当前线程占有的对象锁并让其进入 WAITING 状态，自然是要操作对应的对象（Object）而非当前的线程（Thread）。

Thread.sleep() 是让当前线程暂停执行，不涉及到对象类，也不需要获得对象锁

sleep() 方法和 wait() 方法对比

共同点 ：两者都可以暂停线程的执行。

区别 ：

• sleep() 方法没有释放锁，而 wait() 方法释放了锁 。
• wait() 通常被用于线程间交互/通信，sleep()通常被用于暂停执行。
• wait() 方法被调用后，线程不会自动苏醒，需要别的线程调用同一个对象上的 notify()或者 notifyAll() 方法。sleep()方法执行完成后，线程会自动苏醒，或者也可以使用 wait(long timeout) 超时后线程会自动苏醒。
• sleep() 是 Thread 类的静态本地方法，wait() 则是 Object 类的本地方法。

解除线程的等待状态：Object wait() 方法让当前线程进入等待状态。直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，针对于加锁的对象使用。

 // 删除列表中的元素
    public String removeElement() throws InterruptedException {
        synchronized (synchedList) {
 
            // 列表为空就等待
            while (synchedList.isEmpty()) {
                System.out.println("List is empty...");
                synchedList.wait();
                System.out.println("Waiting...");
            }
            String element = (String) synchedList.remove(0);
 
            return element;
        }
    }
 
    // 添加元素到列表
    public void addElement(String element) {
        System.out.println("Opening...");
        synchronized (synchedList) {
 
            // 添加一个元素，并通知元素已存在
            synchedList.add(element);
            System.out.println("New Element:'" + element + "'");
 
            synchedList.notifyAll();
            System.out.println("notifyAll called!");
        }
        System.out.println("Closing...");
    }

4.线程的阻塞情况

        当线程因为某种原因放弃 CPU 使用权后，即让出了 CPU 时间片，暂时就会停止运行，直到线程进入可运行状态（Runnable），才有机会再次获得 CPU 时间片转入 RUNNING 状态。一般来讲，阻塞的情况可以分为如下三种：

        1.等待阻塞（Object.wait -> 等待队列）

  RUNNING 状态的线程执行 Object.wait() 方法后，JVM 会将线程放入等待序列（waitting queue）；

        2. 同步阻塞（lock -> 锁池）

  RUNNING 状态的线程在获取对象的同步锁时，若该 同步锁被其他线程占用，则 JVM 将该线程放入锁池（lock pool）中；

        3.其他阻塞（sleep/join）

  RUNNING 状态的线程执行 Thread.sleep(long ms) 或 Thread.join() 方法，或发出 I/O 请求时，JVM 会将该线程置为阻塞状态。当 sleep() 状态超时，join() 等待线程终止或超时. 或者 I/O 处理完毕时，线程重新转入可运行状态（RUNNABLE）；        

 

LockSupport.park() 的使用方法

Thread parkThread = new Thread(new Runnable() {
        @Override
        public void run() {

            System.out.println(Thread.currentThread().getName() + "进入park");
            LockSupport.park(this);
            System.out.println(Thread.currentThread().getName() + "解除park");
        }
    }, "parkThread");

Thread unParkThread = new Thread(new Runnable() {
   @Override
   public void run() {
       System.out.println(Thread.currentThread().getName() + "进入unPark");
       LockSupport.unpark(parkThread);
       System.out.println(Thread.currentThread().getName() + "退出unPark");
   }
}, "unParkThread");

二、设计线程安全类

1. 找出构成对象状态的所有变量
2. 找出约束状态变量的不变性条件
3. 建立对象状态的并发访问管理策略

1.收集同步需求

final类型的域（即属性）使用的越多 就越能简化对象可能状态的分析过程

2. 依赖状态操作

如果在某个操作中，必须判断是否能完成这个操作，那这个操作就是依赖状态的

3. 状态的所有权

状态的所有权必须包含在本线程内