裸泳的猪

沾沾自喜其实最可悲

0%

Java基础提升_多线程

发表于 分类于 ， ，

线程创建方式

  1. 继承Thread类
    • start()方法是一个 native 方法,它将启动一个新线程，并执行 run()方法。
  2. 实现runnable接口，
    • 当一个类已经有继承了，此时可通过实现runnable接口来创建线程
  3. 采用线程池，实现callable接口（有返回）,ExecutorService
    • 有返回值的任务必须实现 Callable 接口。执行Callable 任务后，可以获取一个Future 的对象，在该对象上调用 get 就可以获取到 Callable 任务返回的 Object 了，再结合线程池接口 ExecutorService 就可以实现传说中有返回结果的多线程了。

多线程中的主要问题

  1. 可见性问题
    volatile修饰，保证了多线程之间的内存可见性
  2. 原子性问题
    AtomicInteger（Java中有那么一些类，是以Atomic开头的。这一系列的类我们称之为原子操作类。以最简单的类AtomicInteger为例。它相当于一个int变量，我们执行Int的 i++ 的时候并不是一个原子操作。而使用AtomicInteger的incrementAndGet却能保证原子操作）
  3. 有序性问题
    volatile 防止指令重排序
  4. 死锁的问题

synchronized 关键字

用法：

  1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；

  2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；

  3. 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个==类的所有对象==；

  4. 修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。

    原理：

  5. 修饰代码块时：
    synchronized是JVM层面的，同步语句块的实现使用的是monitorenter 和 monitorexit指令，其中 monitorenter 指令指向同步代码块的开始位置，monitorexit 指令则指明同步代码块的结束位置。当执行 monitorenter 指令时，线程试图获取锁也就是获取 monitor(monitor对象存在于每个Java对象的对象头中，synchronized 锁便是通过这种方式获取锁的，也是为什么Java中任意对象可以作为锁的原因)

  6. synchronized 修饰方法时：
    synchronized 修饰的方法并没有 monitorenter 指令和 monitorexit 指令，取而代之的确实是 ACC_SYNCHRONIZED 标识，该标识指明了该方法是一个同步方法，JVM 通过该 ACC_SYNCHRONIZED 访问标志来辨别一个方法是否声明为同步方法，从而执行相应的同步调用。

volatile关键字

作用：保证变量的可见性然后还有一个作用是防止指令重排序。

synchronized关键字和volatile关键字比较

  • volatile关键字是线程同步的轻量级实现，所以volatile性能肯定比synchronized关键字要好。但是volatile关键字只能用于变量而synchronized关键字可以修饰方法以及代码块。synchronized关键字在JavaSE1.6之后进行了主要包括为了减少获得锁和释放锁带来的性能消耗而引入的偏向锁和轻量级锁以及其它各种优化之后执行效率有了显著提升，实际开发中使用 synchronized 关键字的场景还是更多一些。
  • 多线程访问volatile关键字不会发生阻塞，而synchronized关键字可能会发生阻塞
  • volatile关键字能保证数据的可见性，但不能保证数据的原子性。synchronized关键字两者都能保证。
  • volatile关键字主要用于解决变量在多个线程之间的可见性，而 synchronized关键字解决的是多个线程之间访问资源的同步性。

    wait和notify

    wait和notify这两个方法是一对，wait方法阻塞当前线程，而notify是唤醒被wait方法阻塞的线程。

  1. wait()、notify/notifyAll() 方法是Object的本地final方法，无法被重写。

  2. wait()使当前线程阻塞，前提是 必须先获得锁，一般配合synchronized 关键字使用，即，一般在synchronized 同步代码块里使用 wait()、notify/notifyAll() 方法。

  3. 由于 wait()、notify/notifyAll() 在synchronized 代码块执行，说明当前线程一定是获取了锁的。

    当线程执行wait()方法时候，会释放当前的锁，然后让出CPU，进入等待状态。
    只有当 notify/notifyAll() 被执行时候，才会唤醒一个或多个正处于等待状态的线程，然后继续往下执行，直到执行完synchronized 代码块的代码或是中途遇到wait() ，再次释放锁。
    也就是说，notify/notifyAll() 的执行只是唤醒沉睡的线程，而不会立即释放锁，锁的释放要看代码块的具体执行情况。所以在编程中，尽量在使用了notify/notifyAll() 后立即退出临界区，以唤醒其他线程让其获得锁

  4. wait() 需要被try catch包围，以便发生异常中断也可以使wait等待的线程唤醒。

  5. notify 和wait 的顺序不能错，如果A线程先执行notify方法，B线程在执行wait方法，那么B线程是无法被唤醒的。

  6. notify 和 notifyAll的区别
    notify方法只唤醒一个等待（对象的）线程并使该线程开始执行。所以如果有多个线程等待一个对象，这个方法只会唤醒其中一个线程（不确定唤醒哪个），选择哪个线程取决于操作系统对多线程管理的实现。notifyAll 会唤醒所有等待(对象的)线程，尽管哪一个线程将会第一个处理取决于操作系统的实现。如果当前情况下有多个线程需要被唤醒，推荐使用notifyAll 方法。比如在生产者-消费者里面的使用，每次都需要唤醒所有的消费者或是生产者，以判断程序是否可以继续往下执行。

  7. 在多线程中要测试某个条件的变化，使用if 还是while？
    　　要注意，notify唤醒沉睡的线程后，线程会接着上次的执行继续往下执行。所以在进行条件判断时候，可以先把 wait 语句忽略不计来进行考虑；显然，要确保程序一定要执行，并且要保证程序直到满足一定的条件再执行，要使用while进行等待，

Join

join() 定义在Thread.java中。
join() 的作用：让“主线程”等待“子线程”结束之后才能继续运行。
注意：如果线程被生成了，但还未被起动，调用它的 join() 方法是没有作用的，将直接继续向下执行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

// 主线程
public class Father extends Thread {
    public void run() {
        Son s = new Son();
        s.start();
        s.join();
        ...
    }
}
// 子线程
public class Son extends Thread {
    public void run() {
        ...
    }
}

ThreadLocal详解

作用：

  1. 每个线程独立的变量
  2. 可以贯穿整个线程的全局变量，避免参数传递

InheritableThreadLocal

如果我想共享线程的ThreadLocal数据怎么办？使用InheritableThreadLocal可以实现多个线程访问ThreadLocal的值，我们在主线程中创建一个InheritableThreadLocal的实例，然后在子线程中得到这个InheritableThreadLocal实例设置的值。

线程池

1
{% post_link Java基础提升_线程池 Java基础提升_线程池 %}
-------------本文结束感谢您的阅读-------------