多线程相关内容

呜呼~22514

于 2024-09-27 17:17:44 发布

阅读量567

点赞数 11

文章标签： java 开发语言数据结构 intellij-idea

本文链接：https://blog.csdn.net/2302_81083129/article/details/142596579

版权

一、进程与线程

(一)进程的概述

进程是程序的一次执行过程，是系统进行资源分配和调度的一个独立单位。每个进程都有自己独立的内存空间，包括代码、数据和运行时的环境。进程的执行需要系统为其分配各种资源，如 CPU 时间、内存空间、文件描述符等。

(二)线程的概述

线程是进程中的一个执行单元，是操作系统能够进行运算调度的最小单位。一个进程可以包含多个线程，这些线程共享进程的内存空间和资源，同时又有各自独立的执行路径。线程的创建和切换比进程更加轻量级，因此在多任务处理中，线程的使用可以提高系统的并发性和效率。

二、线程的创建

(一)继承Thread类创建多线程

通过继承 java.lang.Thread 类来创建一个线程。具体步骤如下：

1.定义一个子类继承 Thread 类。

2.重写 Thread 类的 run () 方法，在 run () 方法中编写线程要执行的任务代码。

3.创建子类的实例对象。

4.调用实例对象的 start () 方法启动线程。

public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("继承 Thread 类创建多线程。");
    }
}

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

(二)实现Runnable接口创建多线程

实现 java.lang.Runnable 接口也是创建线程的一种方式。步骤如下：

1.定义一个类实现 Runnable 接口。

2.实现 Runnable 接口中的 run () 方法，在 run () 方法中编写线程要执行的任务代码。

3.创建实现类的实例对象。

4.将实例对象作为参数传递给 Thread 类的构造方法，创建 Thread 对象。

5.调用 Thread 对象的 start () 方法启动线程。

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("实现 Runnable 接口创建多线程。");
    }
}

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

(三)实现Callable接口创建多线程

实现 java.util.concurrent.Callable 接口可以创建有返回值的线程。步骤如下：

1.定义一个类实现 Callable 接口，并指定返回值类型。

2.实现 Callable 接口中的 call () 方法，在 call () 方法中编写线程要执行的任务代码，并返回结果。

3.创建实现类的实例对象。

4.将实例对象作为参数传递给 java.util.concurrent.ExecutorService 的 submit () 方法，提交任务并返回一个 Future 对象。

5.可以通过 Future 对象的 get () 方法获取线程的执行结果。

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        return "实现 Callable 接口创建的线程返回的结果。";
    }
}

public class CallableCreationExample {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyCallable callable = new MyCallable();
        FutureTask<String> futureTask = new FutureTask<>(callable);
        Thread thread = new Thread(futureTask);
        thread.start();
        String result = futureTask.get();
        System.out.println(result);
    }
}

三、线程的生命周期及状态转换

(一)新建状态
当一个线程对象被创建后，它就处于新建状态。此时线程还没有开始执行，仅仅是一个对象的存在。

(二)可运行状态
当线程对象调用 start () 方法后，线程进入可运行状态。在这个状态下，线程可能正在运行，也可能在等待 CPU 时间片。

(三)锁阻塞状态
当线程试图获取一个被其他线程占用的锁时，它会进入锁阻塞状态。直到锁被释放，线程才能重新进入可运行状态。

(四)无限等待状态
当线程调用了某些方法，如 Object.wait ()、Thread.join () 等，线程会进入无限等待状态。在这个状态下，线程会一直等待，直到被其他线程唤醒。

(五)计时等到状态
当线程调用了某些带有超时时间的方法，如 Object.wait (long timeout)、Thread.join (long millis) 等，线程会进入计时等到状态。如果在超时时间内没有被唤醒，线程会自动进入可运行状态。

(六)被终止状态
当线程的 run () 方法执行完毕或者线程被中断，线程会进入被终止状态。此时线程不再执行任何任务，并且不能再被启动。

四、线程操作的相关方法

(一)线程优先级

优先级常量	功能描述
static int MAX_PRIORITY	表示线程的最高优先级，值为10
static int MIX_PRIORITY	表示线程的最低优先级，值为1
static int NORM_PRIORITY	表示线程的默认优先级，值为5

Thread thread1 = new Thread(() -> System.out.println("线程 1"));
Thread thread2 = new Thread(() -> System.out.println("线程 2"));
thread1.setPriority(Thread.MIN_PRIORITY);
thread2.setPriority(Thread.MAX_PRIORITY);
thread1.start();
thread2.start();

(二)线程休眠

线程可以通过 Thread.sleep (long millis) 方法进入休眠状态，指定的时间过后，线程会自动唤醒并进入可运行状态。

Thread thread = new Thread(() -> {
    try {
        System.out.println("线程开始执行");
        Thread.sleep(2000);
        System.out.println("线程休眠 2 秒后继续执行");
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
});
thread.start();

(三)线程插队

在 Java 中没有直接的线程插队方法，但是可以通过设置线程优先级来影响线程的执行顺序。优先级高的线程可能会在某些情况下 “插队” 先执行。

(四)线程让步

线程可以通过 Thread.yield () 方法主动让出 CPU 时间片，让其他同优先级的线程有机会执行。但是不能保证让步后的线程一定不会再次被调度执行。

Thread thread = new Thread(() -> {
    for (int i = 0; i < 5; i++) {
        System.out.println("线程执行中");
        Thread.yield();
    }
});
thread.start();

(五)线程中断

可以通过调用线程的 interrupt () 方法来中断一个线程。被中断的线程可以通过 isInterrupted () 方法来检查自己是否被中断，并根据需要进行相应的处理。

Thread thread = new Thread(() -> {
    while (!Thread.currentThread().isInterrupted()) {
        System.out.println("线程执行中");
    }
    System.out.println("线程被中断");
});
thread.start();
try {
    Thread.sleep(1000);
} catch (InterruptedException e) {
    e.printStackTrace();
}
thread.interrupt();

五、线程同步

(一)线程安全

当多个线程同时访问共享资源时，如果不进行同步控制，可能会导致数据不一致等问题。确保在多线程环境下正确处理对共享资源的并发访问就是线程安全。

(二)同步代码块

synchronized (lock) {
    处理共享资源的代码块         
}

(三)同步方法

//synchronized 返回值类型 方法名([参数列表]){}

public class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}

public class SynchronizedMethodExample {
    public static void main(String[] args) {
        Counter counter = new Counter();
        Thread thread1 = new Thread(counter::increment);
        Thread thread2 = new Thread(counter::increment);
        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(counter.getCount());
    }
}

(四)死锁问题

当两个或多个线程相互等待对方持有的资源，而导致所有线程都无法继续执行的情况称为死锁。为了避免死锁，在设计多线程程序时，应该尽量避免多个线程同时持有多个锁，并且要确保在获取锁的顺序上是一致的。同时，应该及时释放不再需要的锁，避免资源的长时间占用。

public class ResourceA {
    public synchronized void useA(ResourceB resourceB) {
        System.out.println("线程持有资源 A，尝试获取资源 B");
        resourceB.useB();
    }
}

public class ResourceB {
    public synchronized void useB() {
        System.out.println("线程持有资源 B，尝试获取资源 A");
    }
}

public class DeadlockExample {
    public static void main(String[] args) {
        ResourceA resourceA = new ResourceA();
        ResourceB resourceB = new ResourceB();
        Thread thread1 = new Thread(() -> resourceA.useA(resourceB));
        Thread thread2 = new Thread(() -> resourceB.useB());
        thread1.start();
        thread2.start();
    }
}