【JAVA】Java高级：多线程与并发编程——线程的创建与管理

原创于 2024-11-25 10:10:13 发布 · 1.1k 阅读

6 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言

JAVA 专栏收录该内容

126 篇文章

订阅专栏

线程是实现并发和多任务处理的核心机制。通过线程，程序可以同时执行多个任务，从而提高应用程序的响应能力和资源利用率。线程的创建与管理是Java开发中一个重要的主题，尤其是在处理I/O密集型任务、网络请求、用户界面更新等场景中。

例如，在一个在线购物网站中，用户浏览商品、添加到购物车、结算等操作可以并行进行，使用线程可以确保用户体验流畅。此外，服务器处理多个用户请求时，线程的有效管理能够显著提高系统的吞吐量。

线程的基本概念

在Java中，线程是轻量级的进程，它是程序执行的基本单位。每个线程都有自己的执行路径和栈空间，可以与其他线程并发执行。Java提供了多种方式来创建和管理线程，主要有以下两种方式：

继承Thread类：通过创建一个子类并重写run()方法。
实现Runnable接口：通过实现Runnable接口并将其传递给Thread对象。

一、创建线程

1. 通过继承`Thread`类

基本思想：创建一个子类继承Thread类，重写run()方法，创建该类的实例并调用start()方法。

示例代码：

// 继承Thread类
class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " - Count: " + i);
            try {
                // 模拟工作，休眠500毫秒
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

// 主类
public class ThreadExample {
    public static void main(String[] args) {
        // 创建线程实例
        MyThread thread1 = new MyThread();
        MyThread thread2 = new MyThread();
        
        // 启动线程
        thread1.start();
        thread2.start();
    }
}

代码解释：

MyThread类继承自Thread类，并重写run()方法，定义了线程的执行逻辑。
在main方法中，创建两个MyThread对象，并调用start()方法启动线程。
Thread.sleep(500)用于模拟线程的工作过程，休眠500毫秒。

2. 通过实现`Runnable`接口

基本思想：实现Runnable接口并将其实例传递给Thread对象，然后调用start()方法。

示例代码：

// 实现Runnable接口
class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " - Count: " + i);
            try {
                // 模拟工作，休眠500毫秒
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

// 主类
public class RunnableExample {
    public static void main(String[] args) {
        // 创建Runnable实例
        MyRunnable myRunnable = new MyRunnable();
        
        // 创建Thread对象
        Thread thread1 = new Thread(myRunnable);
        Thread thread2 = new Thread(myRunnable);
        
        // 启动线程
        thread1.start();
        thread2.start();
    }
}

代码解释：

MyRunnable类实现了Runnable接口，并重写run()方法，定义了线程的执行逻辑。
在main方法中，创建MyRunnable实例，并将其传递给两个Thread对象。
启动线程时，两个线程共享同一个Runnable实例。

二、线程的管理

1. 线程的状态

Java中的线程有多种状态，包括：

新建（New）：线程被创建但尚未启动。
就绪（Runnable）：线程准备好执行，但尚未获得CPU时间。
运行（Running）：线程正在执行。
阻塞（Blocked）：线程因等待锁而被阻塞。
等待（Waiting）：线程等待其他线程的通知。
终止（Terminated）：线程执行完毕。

2. 线程的优先级

Java允许为线程设置优先级，优先级范围为1到10，默认值为5。优先级高的线程在调度时可能会获得更多的CPU时间。

示例代码：

class PriorityThread extends Thread {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " - Priority: " + Thread.currentThread().getPriority());
    }
}

public class ThreadPriorityExample {
    public static void main(String[] args) {
        PriorityThread thread1 = new PriorityThread();
        PriorityThread thread2 = new PriorityThread();
        
        // 设置线程优先级
        thread1.setPriority(Thread.MIN_PRIORITY); // 1
        thread2.setPriority(Thread.MAX_PRIORITY); // 10
        
        thread1.start();
        thread2.start();
    }
}

代码解释：

PriorityThread类继承自Thread，在run()方法中输出线程名称和优先级。
在main方法中，创建两个线程并分别设置它们的优先级。
启动线程后，输出结果可能会因调度策略而有所不同。

三、线程的同步

在多线程环境中，多个线程可能会同时访问共享资源，导致数据不一致。为了解决这个问题，Java提供了多种同步机制。

1. 使用`synchronized`关键字

基本思想：使用synchronized关键字来修饰方法或代码块，确保同一时间只有一个线程可以执行被修饰的代码。

示例代码：

class Counter {
    private int count = 0;

    // 同步方法
    public synchronized void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}

public class SynchronizedExample {
    public static void main(String[] args) {
        Counter counter = new Counter();
        
        // 创建多个线程
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });
        
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });
        
        thread1.start();
        thread2.start();
        
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        System.out.println("Final count: " + counter.getCount());
    }
}

代码解释：

Counter类包含一个共享的count变量和一个同步的increment()方法。
在main方法中，创建两个线程，每个线程执行1000次increment()。
使用join()方法确保主线程在两个子线程完成后再输出最终计数。

2. 使用`ReentrantLock`

基本思想：ReentrantLock是Java提供的更灵活的锁机制，可以替代synchronized关键字，提供了更高级的功能。

示例代码：

import java.util.concurrent.locks.ReentrantLock;

class LockCounter {
    private int count = 0;
    private ReentrantLock lock = new ReentrantLock();

    public void increment() {
        lock.lock(); // 获取锁
        try {
            count++;
        } finally {
            lock.unlock(); // 释放锁
        }
    }

    public int getCount() {
        return count;
    }
}

public class ReentrantLockExample {
    public static void main(String[] args) {
        LockCounter lockCounter = new LockCounter();
        
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                lockCounter.increment();
            }
        });
        
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                lockCounter.increment();
            }
        });
        
        thread1.start();
        thread2.start();
        
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        System.out.println("Final count: " + lockCounter.getCount());
    }
}

代码解释：