Java进程线程

最新推荐文章于 2023-11-26 22:42:54 发布
最新推荐文章于 2023-11-26 22:42:54 发布
阅读量226 收藏 2
点赞数
文章标签： java 多线程 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_46503355/article/details/107907105
版权

Java进程线程

1.进程与线程

1.1 引入

现代操作系统（Windows，macOS，Linux）都可以执行多任务。多任务就是同时运行多个任务。

CPU执行代码都是一条一条顺序执行的，但是，即使是单核cpu，也可以同时运行多个任务。因为操作系统执行多任务实际上就是让CPU对多个任务轮流交替执行。

例如，假设我们有语文、数学、英语3门作业要做，每个作业需要30分钟。我们把这3门作业看成是3个任务，可以做1分钟语文作业，再做1分钟数学作业，再做1分钟英语作业：

这样轮流做下去，在某些人眼里看来，做作业的速度就非常快，看上去就像同时在做3门作业一样。

就像大家现在的状态一样，是不是为了期末考而进行多进程复习呢？

类似的，操作系统轮流让多个任务交替执行，例如，让浏览器执行0.001秒，让QQ执行0.001秒，再让音乐播放器执行0.001秒，在人看来，CPU就是在同时执行多个任务。

即使是多核CPU，因为通常任务的数量远远多于CPU的核数，所以任务也是交替执行的。

这样，你们可以打开任务管理器看看。

1.2 进程

在计算机中，我们把一个任务称为一个进程，浏览器就是一个进程，视频播放器是另一个进程，类似的，音乐播放器和Word都是进程。

某些进程内部还需要同时执行多个子任务。例如，我们在使用Word时，Word可以让我们一边打字，一边进行拼写检查，同时还可以在后台进行打印，我们把子任务称为线程。

总结：所以进程与线程的关系是：一个进程里面可以包含一个或者多个线程。

就像你在做作业一样，手写着字，大脑还在思考一样。

操作系统调度的最小任务单位其实不是进程，而是线程。

因为同一个应用程序，既可以有多个进程，也可以有多个线程，因此，实现多任务的方法，有以下几种：

多进程模式（每个进程只有一个线程）

多线程模式（一个进程有多个线程）

多进程＋多线程模式（复杂度最高）

1.3 进程 vs 线程

进程和线程是包含关系，但是多任务既可以由多进程实现，也可以由单进程内的多线程实现，还可以混合多进程＋多线程。

多进程的缺点在于：

  • 创建进程比创建线程开销大，尤其是在Windows系统上；
  • 进程间通信比线程间通信要慢，因为线程间通信就是读写同一个变量，速度很快。

而多进程的优点在于：

多进程稳定性比多线程高，因为在多进程的情况下，一个进程崩溃不会影响其他进程，而在多线程的情况下，任何一个线程崩溃会直接导致整个进程崩溃。

1.4 多线程

Java语言内置了多线程支持：一个Java程序实际上是一个JVM进程，JVM进程用一个主线程来执行main()方法，在main()方法内部，我们又可以启动多个线程。此外，JVM还有负责垃圾回收的其他工作线程等。

对于大多数Java程序来说，我们说多任务，实际上是说如何使用多线程实现多任务。

和单线程相比，多线程编程的特点在于：多线程经常需要读写共享数据，并且需要同步。例如，播放电影时，就必须由一个线程播放视频，另一个线程播放音频，两个线程需要协调运行，否则画面和声音就不同步。因此，多线程编程的复杂度高，调试更困难。

Java多线程编程的特点又在于：

  • 多线程模型是Java程序最基本的并发模型；
  • 后续读写网络、数据库、Web开发等都依赖Java多线程模型。

因此，必须掌握Java多线程编程才能继续深入学习其他内容。

2.线程创建

Java语言内置了多线程支持。当Java程序启动的时候，实际上是启动了一个JVM进程，然后，JVM启动主线程来执行main()方法。在main()方法中，我们又可以启动其他线程。

要创建一个新线程非常容易，我们需要实例化一个Thread实例，然后调用它的start()方法：

public class Main {
    public static void main(String[] args) {
        Thread t = new Thread();
        t.start(); // 启动新线程
    }
}

但是这个线程启动后实际上什么也不做就立刻结束了。我们希望新线程能执行指定的代码，有以下几种方法：

方法一：从Thread派生一个自定义类，然后覆写run()方法：

public class Main {
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.start(); // 启动新线程
    }
}

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("start new thread!");
    }
}

执行上述代码，注意到start()方法会在内部自动调用实例的run()方法。

方法二：创建Thread实例时，传入一个Runnable实例：

public class test {
    public static void main(String[] args) {
         Thread thread = new Thread(new MyThread());
         thread.start();
    }

}
class MyThread implements Runnable{
    public void run(){
        System.out.println("Thread is coming");
    }
}

方法三：使用Java8出来的lambda表达式：

public class test {
    public static void main(String[] args) {
         Thread thread = new Thread(()->{
             System.out.println("Thread is coming");
         });
         thread.start();
    }

}

方法四：我们还可以使用匿名内部类进行访问：

public class test {
    public static void main(String[] args) {
         Thread thread = new Thread(){
         public void run(){
             System.out.println("Thread is coming");
         }
         };
         thread.start();
    }

}

有童鞋会问，使用线程执行的打印语句，和直接在main()方法执行有区别吗？

区别大了去了。我们看以下代码：

public class Main {
    public static void main(String[] args) {
        System.out.println("main start...");
        Thread t = new Thread() {
            public void run() {
                System.out.println("thread run...");
                System.out.println("thread end.");
            }
        };
        t.start();
        System.out.println("main end...");
    }
}

我们用蓝色表示主线程，也就是main线程，main线程执行的代码有4行，首先打印main start，然后创建Thread对象，紧接着调用start()启动新线程。当start()方法被调用时，JVM就创建了一个新线程，我们通过实例变量t来表示这个新线程对象，并开始执行。

接着，main线程继续执行打印main end语句，而t线程在main线程执行的同时会并发执行，打印thread run和thread end语句。

当run()方法结束时，新线程就结束了。而main()方法结束时，主线程也结束了。

我们再来看线程的执行顺序：

  1. main线程肯定是先打印main start，再打印main end；
  2. t线程肯定是先打印thread run，再打印thread end。

总结：线程主要是执行顺序不一样，首先是main函数线程执行，才会来到我们建立的新线程执行。

但是，除了可以肯定，main start会先打印外，main end打印在thread run之前、thread end之后或者之间，都无法确定。因为从t线程开始运行以后，两个线程就开始同时运行了，并且由操作系统调度，程序本身无法确定线程的调度顺序。

要模拟并发执行的效果，我们可以在线程中调用Thread.sleep()，强迫当前线程暂停一段时间：

sleep()传入的参数是毫秒。调整暂停时间的大小，我们可以看到main线程和t线程执行的先后顺序。

要特别注意：直接调用Thread实例的run()方法是无效的：

public class Main {
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.run();
    }
}

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

直接调用run()方法，相当于调用了一个普通的Java方法，当前线程并没有任何改变，也不会启动新线程。上述代码实际上是在main()方法内部又调用了run()方法，打印hello语句是在main线程中执行的，没有任何新线程被创建。

public class test {
    public static void main(String[] args) {
        Thread thread = new Thread(()->{
            try{
                Thread.sleep(50);
                System.out.println("Thread start");
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            System.out.println("Thread end");
        });
        thread.start();
        try{
            Thread.sleep(25);
            System.out.println("main start");
        }catch(InterruptedException e){
            e.printStackTrace();
        }
        System.out.println("main end");
    }

}

线程的优先级

可以对线程设定优先级，设定优先级的方法是：

Thread.setPriority(int n) // 1~10, 默认值5

优先级高的线程被操作系统调度的优先级较高，操作系统对高优先级线程可能调度更频繁，但我们决不能通过设置优先级来确保高优先级的线程一定会先执行。

3.线程状态

在Java程序中，一个线程对象只能调用一次start()方法启动新线程，并在新线程中执行run()方法。一旦run()方法执行完毕，线程就结束了。因此，Java线程的状态有以下几种：

  • New：新创建的线程，尚未执行；
  • Runnable：运行中的线程，正在执行run()方法的Java代码；
  • Blocked：运行中的线程，因为某些操作被阻塞而挂起；
  • Waiting：运行中的线程，因为某些操作在等待中；
  • Timed Waiting：运行中的线程，因为执行sleep()方法正在计时等待；
  • Terminated：线程已终止，因为run()方法执行完毕。

当线程启动后，它可以在Runnable、Blocked、Waiting和Timed Waiting这几个状态之间切换，直到最后变成Terminated状态，线程终止。

线程终止的原因有：

  • 线程正常终止：run()方法执行到return语句返回；
  • 线程意外终止：run()方法因为未捕获的异常导致线程终止；
  • 对某个线程的Thread实例调用stop()方法强制终止（强烈不推荐使用）。

一个线程还可以等待另一个线程直到其运行结束。例如，main线程在启动t线程后，可以通过t.join()等待t线程结束后再继续运行：

当main线程对线程对象t调用join()方法时，主线程将等待变量t表示的线程运行结束，即join就是指等待该线程结束，然后才继续往下执行自身线程。所以，上述代码打印顺序可以肯定是main线程先打印start，t线程再打印hello，main线程最后再打印end。

public class test {
    public static void main(String[] args) throws InterruptedException {
       Thread thread = new Thread(()->{
           System.out.println("Run");
       });
        System.out.println("start");
        thread.start();
        thread.join();
        System.out.println("end");
    }

}

由于线程执行方法是先执行主线程，再执行我们现在加入的线程。如果没有join，Run方法只有在主线程结束以后才执行的。

如果t线程已经结束，对实例t调用join()会立刻返回。此外，join(long)的重载方法也可以指定一个等待时间，超过等待时间后就不再继续等待。

4.中断线程

如果线程需要执行一个长时间任务，就可能需要能中断线程。中断线程就是其他线程给该线程发一个信号，该线程收到信号后结束执行run()方法，使得自身线程能立刻结束运行。

中断一个线程非常简单，只需要在其他线程中对目标线程调用interrupt()方法，目标线程需要反复检测自身状态是否是interrupted状态，如果是，就立刻结束运行。

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new MyThread();
        t.start();
        Thread.sleep(1); // 暂停1毫秒
        t.interrupt(); // 中断t线程
        t.join(); // 等待t线程结束
        System.out.println("end");
    }
}

class MyThread extends Thread {
    public void run() {
        int n = 0;
        while (! isInterrupted()) {
            n ++;
            System.out.println(n + " hello!");
        }
    }
}

interrupt()方法仅仅向t线程发出了“中断请求”，至于t线程是否能立刻响应，要看具体代码。而t线程的while循环会检测isInterrupted()，所以上述代码能正确响应interrupt()请求，使得自身立刻结束运行run()方法。

如果线程处于等待状态，例如，t.join()会让main线程进入等待状态，此时，如果对main线程调用interrupt()，join()方法会立刻抛出InterruptedException，因此，目标线程只要捕获到join()方法抛出的InterruptedException，就说明有其他线程对其调用了interrupt()方法，通常情况下该线程应该立刻结束运行。

我们又看一个代码：

package com.java.LOL;

public class test {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new MyThread();
        t.start();
        Thread.sleep(100); // 暂停1毫秒
        t.interrupt(); // 中断t线程
        t.join(); // 等待t线程结束
        System.out.println("end");
    }
}

class MyThread extends Thread {
    Thread t = new HelloThread();
    public void run() {
        t.start();
        try{
            t.join();
        }catch (InterruptedException e){
            System.out.println(e.getMessage());
        }
        t.interrupt();
    }
}
class HelloThread extends Thread{
    public void run(){
        int n = 0;
        while (! isInterrupted()) {
            n++;
            System.out.println("我错了！"+n);
            try{
                Thread.sleep(500);
            }catch (InterruptedException e){
                
                break;
            }
        }

    }
}

这段代码主要是线程嵌套，我们在第一个线程里面又嵌套了第二个线程，但是代码量有点大，我们可以简化一下：

另一个常用的中断线程的方法是设置标志位。我们通常会用一个running标志位来标识线程是否应该继续运行，在外部线程中，通过把HelloThread.running置为false，就可以让线程结束：

我们来看一段代码：

package com.java.LOL;

public class test {
    public static void main(String[] args) throws InterruptedException {
       MyThread thread = new MyThread();
       thread.start();
       Thread.sleep(50);
       thread.running = false;
    }
}

class MyThread extends Thread{
    public volatile boolean running = true;
    public void run(){
        int n = 0;
        while(running){
            n++;
            System.out.println("我错了！"+n);
        }
        System.out.println("end!");
    }
}

注意到HelloThread的标志位boolean running是一个线程间共享的变量。线程间共享变量需要使用volatile关键字标记，确保每个线程都能读取到更新后的变量值。

volatile关键字：是Java并发编程中比较重要的一个关键字。和synchronized不同，volatile是一个变量修饰符，只能用来修饰变量。无法修饰方法及代码块等。

volatile的用法比较简单，只需要在声明一个可能被多线程同时访问的变量时，使用volatile修饰就可以了。

其实就是线程共享了。

这会导致如果一个线程更新了某个变量，另一个线程读取的值可能还是更新前的。

因此，volatile关键字的目的是告诉虚拟机：

  • 每次访问变量时，总是获取主内存的最新值；
  • 每次修改变量后，立刻回写到主内存。

volatile关键字解决的是可见性问题：当一个线程修改了某个共享变量的值，其他线程能够立刻看到修改后的值。

可以增加线程进行值的稳定性。

5.线程守护

Java程序入口就是由JVM启动main线程，main线程又可以启动其他线程。当所有线程都运行结束时，JVM退出，进程结束。

如果有一个线程没有退出，JVM进程就不会退出。所以，必须保证所有线程都能及时结束。

但是我们有可能一不小心就进入了死循环。

class TimerThread extends Thread {
    @Override
    public void run() {
        while (true) {
            System.out.println(LocalTime.now());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                break;
            }
        }
    }
}

如果这个线程不结束，JVM进程就无法结束。

我们要怎么结束这个线程呢？

我们就引入了一个守护线程的概念。

守护线程是指为其他线程服务的线程。在JVM中，所有非守护线程都执行完毕后，无论有没有守护线程，虚拟机都会自动退出。

因此，JVM退出时，不必关心守护线程是否已结束。

如何创建守护线程呢？方法和普通线程一样，只是在调用start()方法前，调用setDaemon(true)把该线程标记为守护线程：

Thread t = new MyThread();
t.setDaemon(true);
t.start();

在守护线程中，编写代码要注意：守护线程不能持有任何需要关闭的资源，例如打开文件等，因为虚拟机退出时，守护线程没有任何机会来关闭文件，这会导致数据丢失。

我们看一个代码：

package com.java.LOL;

import java.time.LocalTime;

public class test {
    public static void main(String[] args) throws InterruptedException {
       MyThread thread = new MyThread();
       thread.setDaemon(true);
       thread.run();
    }
}

class MyThread extends Thread{
    public void run(){
        while(true){
            System.out.println(LocalTime.now());
            try{
                Thread.sleep(1000);
            }catch (InterruptedException e){
                break;
            }
        }
    }
}

总结一下：

守护线程是为其他线程服务的线程；

所有非守护线程都执行完毕后，虚拟机退出；

守护线程不能持有需要关闭的资源（如打开文件等）。

6.线程同步

当多个线程同时运行时，线程的调度由操作系统决定，程序本身无法决定。因此，任何一个线程都有可能在任何指令处被操作系统暂停，然后在某个时间段后继续执行。

这个时候，有个单线程模型下不存在的问题就来了：如果多个线程同时读写共享变量，会出现数据不一致的问题。

看一个代码：

public class Main {
    public static void main(String[] args) throws Exception {
        var add = new AddThread();
        var dec = new DecThread();
        add.start();
        dec.start();
        add.join();
        dec.join();
        System.out.println(Counter.count);
    }
}

class Counter {
    public static int count = 0;
}

class AddThread extends Thread {
    public void run() {
        for (int i=0; i<10000; i++) { Counter.count += 1; }
    }
}

class DecThread extends Thread {
    public void run() {
        for (int i=0; i<10000; i++) { Counter.count -= 1; }
    }
}

我们有可能希望值是0，但是会出现多种情况。

原因在于线程执行是jvm随机调用的一个过程，这是因为对变量进行读取和写入时，结果要正确，必须保证是原子操作。原子操作是指不能被中断的一个或一系列操作。

这说明多线程模型下，要保证逻辑正确，对共享变量进行读写时，必须保证一组指令以原子方式执行：即某一个线程执行时，其他线程必须等待

通过加锁和解锁的操作，就能保证3条指令总是在一个线程执行期间，不会有其他线程会进入此指令区间。

可见，保证一段代码的原子性就是通过加锁和解锁实现的。Java程序使用synchronized关键字对一个对象进行加锁：

synchronized(lock) {
    n = n + 1;
}

synchronized保证了代码块在任意时刻最多只有一个线程能执行。我们把上面的代码用synchronized改写如下：

package com.java.LOL;

public class test {
    public static void main(String[] args) throws InterruptedException {
        Thread1 thread1 = new Thread1();
        Thread2 thread2 = new Thread2();
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
        System.out.println(Counter.count);
    }
}

class Counter{
    public static final Object lock = new Object();
    public static int count = 0;
}

class Thread1 extends Thread{
    public void run(){
        for (int i = 0; i < 10000; i++) {
            synchronized (Counter.lock){
                Counter.count++;
            }
        }
    }
}

class Thread2 extends Thread{
    public void run(){
        for (int i = 0; i < 10000; i++) {
            synchronized (Counter.lock){
                 Counter.count--;
            }
        }
    }
}

结果就对了。

synchronized(Counter.lock) { // 获取锁
    ...
} // 释放锁

它表示用Counter.lock实例作为锁，两个线程在执行各自的synchronized(Counter.lock) { ... }代码块时，必须先获得锁，才能进入代码块进行。执行结束后，在synchronized语句块结束会自动释放锁。这样一来，对Counter.count变量进行读写就不可能同时进行。上述代码无论运行多少次，最终结果都是0。

这个就相当于一个锁，就是依次进行相关线程。

使用synchronized解决了多线程同步访问共享变量的正确性问题。但是，它的缺点是带来了性能下降。因为synchronized代码块无法并发执行。此外，加锁和解锁需要消耗一定的时间，所以，synchronized会降低程序的执行效率。

方法：

我们在上述代码上面进行改进：

public class Counter {
    private int count = 0;

    public void add(int n) {
        synchronized(this) {
            count += n;
        }
    }

    public void dec(int n) {
        synchronized(this) {
            count -= n;
        }
    }

    public int get() {
        return count;
    }
}

这样一来，线程调用add()、dec()方法时，它不必关心同步逻辑，因为synchronized代码块在add()、dec()方法内部。并且，我们注意到，synchronized锁住的对象是this，即当前实例，这又使得创建多个Counter实例的时候，它们之间互不影响，可以并发执行：

var c1 = Counter();
var c2 = Counter();

// 对c1进行操作的线程:
new Thread(() -> {
    c1.add();
}).start();
new Thread(() -> {
    c1.dec();
}).start();

// 对c2进行操作的线程:
new Thread(() -> {
    c2.add();
}).start();
new Thread(() -> {
    c2.dec();
}).start();

如果一个类被设计为允许多线程正确访问，我们就说这个类就是“线程安全”的（thread-safe），上面的Counter类就是线程安全的。Java标准库的java.lang.StringBuffer也是线程安全的。

还有一些不变类，例如String，Integer，LocalDate，它们的所有成员变量都是final，多线程同时访问时只能读不能写，这些不变类也是线程安全的。

最后，类似Math这些只提供静态方法，没有成员变量的类，也是线程安全的。

除了上述几种少数情况，大部分类，例如ArrayList，都是非线程安全的类，我们不能在多线程中修改它们。

我们再回过头来看看counter代码：

当我们锁住的是this实例时，实际上可以用synchronized修饰这个方法。下面两种写法是等价的：

public void add(int n) {
    synchronized(this) { // 锁住this
        count += n;
    } // 解锁
}
public synchronized void add(int n) { // 锁住this
    count += n;
} // 解锁

因此，用synchronized修饰的方法就是同步方法，它表示整个方法都必须用this实例加锁。

对于static方法，是没有this实例的，因为static方法是针对类而不是实例。但是我们注意到任何一个类都有一个由JVM自动创建的Class实例，因此，对static方法添加synchronized，锁住的是该类的Class实例。

public class Counter {
    public static void test(int n) {
        synchronized(Counter.class) {
            ...
        }
    }
}

7.死锁

一个线程在获取一个锁以后还可以再获得另外一把锁。

public void add(int m) {
    synchronized(lockA) { // 获得lockA的锁
        this.value += m;
        synchronized(lockB) { // 获得lockB的锁
            this.another += m;
        } // 释放lockB的锁
    } // 释放lockA的锁
}

public void dec(int m) {
    synchronized(lockB) { // 获得lockB的锁
        this.another -= m;
        synchronized(lockA) { // 获得lockA的锁
            this.value -= m;
        } // 释放lockA的锁
    } // 释放lockB的锁
}

在获取多个锁的时候，不同线程获取多个不同对象的锁可能导致死锁。对于上述代码，线程1和线程2如果分别执行add()和dec()方法时：

  • 线程1：进入add()，获得lockA；
  • 线程2：进入dec()，获得lockB。

随后：

  • 线程1：准备获得lockB，失败，等待中；
  • 线程2：准备获得lockA，失败，等待中。

此时，两个线程各自持有不同的锁，然后各自试图获取对方手里的锁，造成了双方无限等待下去，这就是死锁。

总结：死锁就是在线程里面加入了不同对象的锁以后就导致程序无法运行的锁。

死锁发生后，没有任何机制能解除死锁，只能强制结束JVM进程。

因此，在编写多线程应用时，要特别注意防止死锁。因为死锁一旦形成，就只能强制结束进程。

那么我们应该如何避免死锁呢？答案是：线程获取锁的顺序要一致。即严格按照先获取lockA，再获取lockB的顺序，改写dec()方法如下：

public void dec(int m) {
    synchronized(lockA) { // 获得lockA的锁
        this.value -= m;
        synchronized(lockB) { // 获得lockB的锁
            this.another -= m;
        } // 释放lockB的锁
    } // 释放lockA的锁
}

8.wait和notify

在Java程序中，synchronized解决了多线程竞争的问题。例如，对于一个任务管理器，多个线程同时往队列中添加任务，可以用synchronized加锁：

class TaskQueue {
    Queue<String> queue = new LinkedList<>();

    public synchronized void addTask(String s) {
        this.queue.add(s);
    }

    public synchronized String getTask() {
        while (queue.isEmpty()) {
        }
        return queue.remove();
    }
}

上述代码看上去没有问题：getTask()内部先判断队列是否为空，如果为空，就循环等待，直到另一个线程往队列中放入了一个任务，while()循环退出，就可以返回队列的元素了。

但实际上while()循环永远不会退出。因为线程在执行while()循环时，已经在getTask()入口获取了this锁，其他线程根本无法调用addTask()，因为addTask()执行条件也是获取this锁。

对于上述TaskQueue，我们先改造getTask()方法，在条件不满足时，线程进入等待状态：

public synchronized String getTask() {
    while (queue.isEmpty()) {
        this.wait();
    }
    return queue.remove();
}

当一个线程执行到getTask()方法内部的while循环时，它必定已经获取到了this锁，此时，线程执行while条件判断，如果条件成立（队列为空），线程将执行this.wait()，进入等待状态。

这里的关键是：wait()方法必须在当前获取的锁对象上调用，这里获取的是this锁，因此调用this.wait()。

调用wait()方法后，线程进入等待状态，wait()方法不会返回，直到将来某个时刻，线程从等待状态被其他线程唤醒后，wait()方法才会返回，然后，继续执行下一条语句。

现在我们面临第二个问题：如何让等待的线程被重新唤醒，然后从wait()方法返回？答案是在相同的锁对象上调用notify()方法。我们修改addTask()如下：

public synchronized void addTask(String s) {
    this.queue.add(s);
    this.notify(); // 唤醒在this锁等待的线程
}

使用notifyAll()将唤醒所有当前正在this锁等待的线程，而notify()只会唤醒其中一个（具体哪个依赖操作系统，有一定的随机性）。

9.Lock

我们在使用线程里面也许还有不安全，我们还可以加入方法：Lock接口，我们使用ReentrantLock。

public class Counter {
    private final Lock lock = new ReentrantLock();
    private int count;

    public void add(int n) {
        lock.lock();
        try {
            count += n;
        } finally {
            lock.unlock();
        }
    }
}

因为synchronized是Java语言层面提供的语法，所以我们不需要考虑异常，而ReentrantLock是Java代码实现的锁，我们就必须先获取锁，然后在finally中正确释放锁。

使用ReentrantLock比直接使用synchronized更安全，可以替代synchronized进行线程同步。

答案是使用Condition对象来实现wait和notify的功能。

我们仍然以TaskQueue为例，把前面用synchronized实现的功能通过ReentrantLock和Condition来实现：

class TaskQueue {
    private final Lock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();
    private Queue<String> queue = new LinkedList<>();

    public void addTask(String s) {
        lock.lock();
        try {
            queue.add(s);
            condition.signalAll();
        } finally {
            lock.unlock();
        }
    }

    public String getTask() {
        lock.lock();
        try {
            while (queue.isEmpty()) {
                condition.await();
            }
            return queue.remove();
        } finally {
            lock.unlock();
        }
    }
}

Condition提供的await()、signal()、signalAll()原理和synchronized锁对象的wait()、notify()、notifyAll()是一致的，并且其行为也是一样的：

  • await()会释放当前锁，进入等待状态；
  • signal()会唤醒某个等待线程；
  • signalAll()会唤醒所有等待线程；
  • 唤醒线程从await()返回后需要重新获得锁。

此外，和tryLock()类似，await()可以在等待指定时间后，如果还没有被其他线程通过signal()或signalAll()唤醒，可以自己醒来：

Condition可以替代wait和notify；

Condition对象必须从Lock对象获取。

这个是Java5以后有的。

10.读写锁

使用ReadWriteLock可以解决线程读写问题，因为前面问题导致了一个东西：只能读不能写，它保证：

  • 只允许一个线程写入（其他线程既不能写入也不能读取）；
  • 没有写入时，多个线程允许同时读（提高性能）。

用ReadWriteLock实现这个功能十分容易。我们需要创建一个ReadWriteLock实例，然后分别获取读锁和写锁：

public class Counter {
    private final ReadWriteLock rwlock = new ReentrantReadWriteLock();
    private final Lock rlock = rwlock.readLock();
    private final Lock wlock = rwlock.writeLock();
    private int[] counts = new int[10];

    public void inc(int index) {
        wlock.lock(); // 加写锁
        try {
            counts[index] += 1;
        } finally {
            wlock.unlock(); // 释放写锁
        }
    }

    public int[] get() {
        rlock.lock(); // 加读锁
        try {
            return Arrays.copyOf(counts, counts.length);
        } finally {
            rlock.unlock(); // 释放读锁
        }
    }
}

把读写操作分别用读锁和写锁来加锁，在读取时，多个线程可以同时获得读锁，这样就大大提高了并发读的执行效率。

11.stampedLock

要进一步提升并发执行效率，Java 8引入了新的读写锁：StampedLock。

StampedLock和ReadWriteLock相比，改进之处在于：读的过程中也允许获取写锁后写入！这样一来，我们读的数据就可能不一致，所以，需要一点额外的代码来判断读的过程中是否有写入，这种读锁是一种乐观锁。

代码实例：

public class Point {
    private final StampedLock stampedLock = new StampedLock();

    private double x;
    private double y;

    public void move(double deltaX, double deltaY) {
        long stamp = stampedLock.writeLock(); // 获取写锁
        try {
            x += deltaX;
            y += deltaY;
        } finally {
            stampedLock.unlockWrite(stamp); // 释放写锁
        }
    }

    public double distanceFromOrigin() {
        long stamp = stampedLock.tryOptimisticRead(); // 获得一个乐观读锁
        // 注意下面两行代码不是原子操作
        // 假设x,y = (100,200)
        double currentX = x;
        // 此处已读取到x=100，但x,y可能被写线程修改为(300,400)
        double currentY = y;
        // 此处已读取到y，如果没有写入，读取是正确的(100,200)
        // 如果有写入，读取是错误的(100,400)
        if (!stampedLock.validate(stamp)) { // 检查乐观读锁后是否有其他写锁发生
            stamp = stampedLock.readLock(); // 获取一个悲观读锁
            try {
                currentX = x;
                currentY = y;
            } finally {
                stampedLock.unlockRead(stamp); // 释放悲观读锁
            }
        }
        return Math.sqrt(currentX * currentX + currentY * currentY);
    }
}

注意到首先我们通过tryOptimisticRead()获取一个乐观读锁，并返回版本号。

如果在读取过程中有写入，版本号会发生变化，验证将失败。在失败的时候，我们再通过获取悲观读锁再次读取。由于写入的概率不高，程序在绝大部分情况下可以通过乐观读锁获取数据，极少数情况下使用悲观读锁获取数据。

至于Concurrent集合，大家就看看官网：https://www.liaoxuefeng.com/wiki/1252599548343744/1306581060812834

线程池：https://www.liaoxuefeng.com/wiki/1252599548343744/1306581130018849

试音刀郎
关注
java线程与进程
mmoren的博客
03-26 5555
线程：1）进程中负责程序执行的执行单元2）依靠程序执行的顺序控制流，只能使用程序的资源和环境，共享进程的全部资源3）有自己的堆栈和局部变量，没有单独的地址空间4）CPU调度和分派的基本单位，持有程序计数器，寄存器，堆栈进程：1）系统资源分配和调度的独立单位2）至少包含一个线程3）拥有自己的资源创建线程的方式：1）继承Thread类，实现run方法2）实现Runnable接口，实现run方法，用实现...
Java高级篇--进程和线程
m0_74194490的博客
07-03 549
正在进行的程序。是系统分配资源的基本单元。线程轻量级线程）是进程中的一条执行路径，也就是CPU的基本调度单位。多线程：一个程序同一时间执行多个线程。一个进程由一个或多个线程组成，彼此之间完成的工作不同（任务），同时执行，成为多线程。--我们写的代码就是单线程的。
java进程线程
weixin_44804206的博客
08-13 496
程序、进程、线程 程序是一个静态代码块，它是应用程序执行的蓝本。 进程：是指一种正在 运行的程序，有自己的地址空间 进程的特点：动态性，并发性 ，独立性 线程：进程内部的一个执行单元，它是程序中一个单一的顺序控制流程 线程特点：轻量级进程、独立调度的基本单位（时间片）、可并发执行、共享进程资源 并发与并行的区别 并发：多个cpu同时执行多个任务 并行：一个CPU（采用时间片）同时执行多个任务 创建线程方式 方式一 ：继承Thread,重写run() 创建线程：class TortoiseThread ext
JAVA中进程、线程
renjie3274的博客
09-04 350
进程与线程的概念 进程：一次程序的执行，是系统资源调度和分配的基本单位 线程：是进程中独立运行的子任务，是CPU调度和分配的基本单位，线程被调用的时机是随机的。 进程与线程的关系： 1.一个进程可以有多个线程，一个线程只能属于一个进程 2.系统分配资源给进程，同一进程的线程共享该进程的资源 3.进程间可以并发执行，同一进程的线程也可以并发执行 进程的通讯方法 1.管道：具有亲缘关系...
java 进程线程_Java中程序、线程、进程解析
weixin_39999190的博客
02-12 95
程序 (program) 是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态的对象。进程 (process) 是程序的一次执行过程，或是正在运行的一个程序。动态过程：有它自身的产生、存在和消亡的过程。如：运行中的QQ，运行中的MP3播放器程序是静态的，进程是动态的线程 (thread) ，进程可进一步细化为线程，是一个程序内部的一条执行路径。线程是分配cpu的最小单位何时需...
java进程线程_Java进程线程笔记
weixin_29093017的博客
02-20 139
什么是并行和并发？并发和并行是即相似又有区别：(微观)并行：指两个或多个事件在同一时刻发生； 强调的是时间点.并发：指两个或多个事件在同一时间段内发生； 强调的是时间段.进程和线程的区别？进程：有独立的内存空间，进程中的数据存放空间(堆空间和栈空间)是独立的，至少有一个线程。 线程：堆空间是共享的，栈空间是独立的，线程消耗的资源也比进程小，相互之间可以影响的，又称为轻型进程或进程元。 因为一个进程...
Java-进程与线程
qq_51302219的博客
08-04 611
java进程、线程基础
【Java多线程学习1】什么是进程、线程，什么是并发、并行及线程的创建和线程的基本使用
weixin_43950588的博客
01-02 966
什么是线程、进程，什么是并发、并行及线程的创建和基本使用
JAva进程和线程管理
12-09
Java进程和线程管理的知识点涵盖了进程、线程、多进程、多线程、主线程、创建和启动线程的基本概念及其在Java中的实现方式。首先，进程被定义为系统进行资源分配和调度的独立单位，拥有自己的内存空间和系统资源。在...
Java面试多线程与进程通信核心知识点详解：进程线程区别、同步机制与死锁预防
最新发布
04-07
内容概要：本文档详细介绍了Java面试中常见的操作系统相关知识点，包括进程线程的区别、进程通信方式、僵尸进程、进程同步PV信号量、死锁及其避免方法（如银行家算法）、同步异步阻塞非阻塞的概念、操作系统CPU调度...
java进程线程_【Java 并发编程系列1】 进程与线程
weixin_32441957的博客
02-20 102
Java 从诞生起就明智的支持多线程。线程作为操作系统的调度的最小单元，多个线程合理的并发执行能够明显的提高程序性能。但是不当的使用多程序或者过多的创建线程也会是程序性能降低。所以学习如何使用多线程是每个开发者都必须要面对的过程。1、什么是进程？进程是操作系统的基础，是一次的程序执行，是一个程序及其数据在处理机上顺序执行所发生的活动，它是系统进行资源分配的独立单位。一个进程可以包含多个线程，每个线...
JAVA 进程线程详解
weixin_68320784的博客
04-09 2207
线程和进程 一、进程 进程是指运行中的程序，比如我们使用QQ，就启动该进程分配内存空间. 进程是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自升的产生，存在和消亡的过程 二、线程 线程是由进程创建的，是进程的一个实体 一个进程可以拥有多个线程 一个想线程还可以创建它的子线程 三、其他概念 单线程：同时允许执行一个线程 多线程：同一个时刻，可以执行多个线程 比如：QQ可以打开多个聊天窗口，一个迅雷进程，可以同时下载多个文件 并发：同一个时刻，
java 进程和线程
ydyww的博客
11-22 186
是范德萨
JAVA进程和线程
程序猿追的博客
11-06 9445
进程就是正在运行的程序，它是系统资源调度的独立单位，并且一个进程可以执行多个任务，而线程就是程序执行的任务，它是程序使用CPU的基本单位，因此也可以说线程是依赖于进程的。像比如任务管理器里面的运行任务就是线程。
java进程和线程
qq_45193833的博客
07-16 180
这里写自定义目录标题#前言java进程和线程的基本概念1.1 进程产⽣的背景#批处理操作系统#进程的提出#对操作系统的要求进一步提高#线程的提出#进程和线程的区别 #前言 阅读深入浅出+java+多线程记录 java进程和线程的基本概念 1.1 进程产⽣的背景 最初的计算机只能接受一些特定的指令，用户每输入一个指令，计算机就执行一条指令并操作。当用户在思考或者输入时，计算机就在等待哦。这样效率非常低下，在很多时候，计算机都处在等在状态。 #批处理操作系统 后来有了批处理操作系统，把一系列需要操作的指令写下来
java 进程线程_Java线程和进程概述
weixin_39607447的博客
02-20 112
几乎所有的操作系统都支持同时运行多个任务，一个任务通常就是一一个程序,每个运行中的程序就是一个进程。当一个程序运行时，内部可能包含了多个顺序执行流，每个顺序执行流就是-一个线程。线程和进程几乎所有的操作系统都支持进程的概念，所有运行中的任务通常对应一个进程(Process)。 当一个程序进入内存运行时，即变成一个进程。进程是处于运行过程中的程序，并且具有一定的独立功能，进程是系统进行资源分配和调度...
Java之进程和线程
NoviceZ的博客
06-03 939
深入理解进程和线程 生动形象的比喻： 进程：一个车间 = 一个进程； （即一个运行的程序） 多进程：一座工厂可以同时运行多个车间； CPU和进程：单CPU只能同时运行单个进程，多CPU可以同时运行多个进程。 线程分为单线程和多线程 单线程：车间内一个工人 = 一个线程； 多线程：车间内多个工人 = 多个线程； 进程与线程：一个进程可以包括多个线程。 线程间内存共享：一个车间的空间是工人们共享的，比如许多房间是每个工人都可以进出的。 同理一个进程的内存空间是共享的，里面的每个线..
JAVA进程与线程
m0_69468924的博客
11-26 1311
JAVA进程与线程
java 进程线程_Java多线程（一）：线程与进程
weixin_42208552的博客
02-20 113
1.线程和进程1.1 进程进程是操作系统的概念，我们运行的一个TIM.exe就是一个进程。进程(Process)是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体1.2 线程线程是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值