Java并发——基础知识

不念不忘少年蓝@ 2024-03-29 14:44 196阅读 0赞

### 一、并发基础 ###

#### **1. 多线程的作用** ####

平衡**CPU**、**内存**、**I/O设备**的速度差异，合理利用CPU的高性能

*  CPU增加了缓存，来均衡与内存的速度差异 （导致可见性问题）
 *  操作系统增加了进程、线程，以分时复用CPU来均衡CPU与I/O设备的速度差异（导致原子性问题）
 *  编译程序优化指令执行次序，使得缓存能够更加合理的运用 （导致有序性问题）

#### **2. 并发三要素** ####

**可见性：** 一个线程对共享变量的修改，另外一个线程能够立刻看到（CPU缓存引起不可见性）

**原子性：** 多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。（分时复用引起）

**有序性：** 程序执行的顺序按照代码的先后顺序执行 （指令重排会打乱顺序）

#### **3. Java 原子性保证** ####

Java内存模型只保证了**基本读取**和**简单赋值（如a = 10）操作是原子性的，其他实现需要通过synchronized**和**Lock**来实现。由于**synchronized**和**Lock**能够保证任一时刻只有一个线程执行该代码块，那么自然就不存在原子性问题了，从而保证了原子性。

#### **4. Java可见性保证** ####

Java提供了**volatile**关键字来保证可见性。当一个共享变量被`volatile`修饰时，它会保证修改的值会立即被更新到主存，当有其他线程需要读取时，它会去内存中读取新值。

而普通的共享变量不能保证可见性，因为普通共享变量被修改之后，什么时候被写入主存是不确定的，当其他线程去读取时，此时内存中可能还是原来的旧值，因此无法保证可见性。

通过`synchronized`和`Lock`也能够保证可见性，`synchronized`和`Lock`能保证同一时刻只有一个线程获取锁然后执行同步代码，并且在释放锁之前会将对变量的修改刷新到主存当中。因此可以保证可见性

#### **5. Java有序性保证** ####

`synchronized`和`Lock`

`synchronized`和`Lock`保证每个时刻是有一个线程执行同步代码，相当于是让线程顺序执行同步代码，自然就保

证了有序性。当然JMM是通过`Happens-Before` 规则来保证有序性的。

### 二、线程基础 ###

#### **1. Java中线程的使用方式** ####

有三种使用线程的方法:**实现 Runnable 接口**；**实现 Callable 接口**；**继承 Thread 类**。

**实现Runnable接口的例子：**

public static void main(String[] args) {
        
         MyRunnable myRunnable = new MyRunnable();
         Thread thread = new Thread(myRunnable);
         thread.start();
         
        }
     public static class  MyRunnable implements Runnable{
        
    
           @Override
           public void run() {
        
    
           }
     }

**实现Callable接口的例子：**

public class Test {
        
    
        public static void main(String[] args) {
        
        MyCallable myCallable = new MyCallable();
            FutureTask<String> futureTask = new FutureTask<>(myCallable);
            Thread thread = new Thread(futureTask);
            thread.start();
            try {
        
                // 获取返回结果
                System.out.println(futureTask.get());
            } catch (Exception e) {
        
                e.printStackTrace();
            }
        }
       public static class  MyCallable implements Callable<String> {
        
           @Override
           public String call() throws Exception {
        
               return "ok";
           }
       }
    }

**继承Thread类**

public class Test {
        
    
        public static void main(String[] args) {
        
             MyThread thread = new MyThread();
             thread.start();
        }
       public static class  MyThread extends Thread{
        
           @Override
           public void run() {
        
               super.run();
           }
       }
    }

实现`Runnable` 和 `Callable` 接口的类只能当做一个可以在线程中运行的任务，不是真正意义上的线程，因此最后还需要通过 `Thread` 来调用。可以说任务是通过线程驱动从而执行的

**`Runnable`和`Callable`的区别**

`Callable` 可以有返回值，返回值通过 `FutureTask` 进行封装。

当调用 `start()`方法启动一个线程时，虚拟机会将该线程放入就绪队列中等待被调度，当一个线程被调度时会执行该线程的`run()`方法。

如何选择，实现接口更好，因为Java不支持多继承，如果继承`Thread`类就不能继承其他类了，接口也更轻量。实际上`Thread`类以也实现了`Runnable`

#### **2. Daemon守护线程** ####

守护线程是程序运行时在后台提供服务的线程，不属于程序中不可或缺的部分。

当所有非守护线程结束时，程序也就终止，同时会杀死所有守护线程。`main()` 属于非守护线程。

使用 `setDaemon()`方法将一个线程设置为守护线程。

public static void main(String[] args) {
        
             Thread thread = new Thread();
             thread.setDaemon(true);
        }

#### **3. sleep()** ####

`Thread.sleep(millisec)`方法会休眠当前正在执行的线程，`millisec` 单位为毫秒。

`sleep()`可能会抛出 `InterruptedException`，因为异常不能跨线程传播回 `main()` 中，所以必须在本地进行处理。线程中抛出的其它异常也同样需要在本地进行处理。

try {
        
                Thread.sleep(1000);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }

#### **4. join()** ####

在线程中调用另一个线程的`join()`方法，会将当前线程挂起，而不是忙等待，直到目标线程结束

#### **5. wait() notify() notifyAll()** ####

调用`wait()`使得线程等待某个条件满足，线程在等待时会被挂起，当其他线程的运行使得这个条件满足时，其它线程会调用`notify()`或者`notifyAll()`来唤醒挂起的线程。

它们都属于 `Object` 的一部分，而不属于`Thread`。

只能用在**同步方法**或者**同步控制块**中，否则会在运行时抛出 `IllegalMonitorStateExeception`。

使用`wait()`挂起期间，线程会释放锁。这是因为，如果没有释放锁，那么其它线程就无法进入对象的同步方法或者同步控制块中，那么就无法执行`notify()`或者`notifyAll()`来唤醒挂起的线程，造成死锁。

#### **6. wait() 和 sleep() 的区别** ####

*  `wait()`是 `Object` 的方法，而 `sleep()` 是 `Thread` 的静态方法；
 *  `wait()`会释放锁，`sleep()`不会。

#### **7. await() signal() signalAll()** ####

`java.util.concurrent`类库中提供了 `Condition`类来实现线程之间的协调，可以在 `Condition`上调用`await()`方法使线程等待，其它线程调用 `signal()`或 `signalAll()` 方法唤醒等待的线程。相比于`wait()`这种等待方式，`await()`可以指定等待的条件，因此更加灵活。

使用 `Lock`来获取一个 `Condition`对象。