Java线程 - Java

简介

Java线程是Java编程语言中的一种基本的并发编程机制。线程允许程序同时执行多个任务，提高了程序的并发性能和响应速度。Java线程通过使用操作系统提供的线程机制，实现了并发性。

Java线程支持创建和管理线程，以及线程间的通信和同步。使用线程，可以将程序分为多个独立的执行流，每个执行流都可以执行自己的任务，并且可以在任何时候进行交互和同步。

线程的创建与启动

Java线程可以通过以下两种方式进行创建：

1. 继承Thread类

class MyThread extends Thread {
    public void run(){
        // 执行线程任务的代码
    }
}

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

2. 实现Runnable接口

class MyRunnable implements Runnable {
    public void run(){
        // 执行线程任务的代码
    }
}

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

线程的状态和生命周期

Java线程有以下几个状态：

• 新建(New): 当线程对象被创建但还没有调用start()方法时处于新建状态。
• 就绪(Runnable): 当线程对象调用了start()方法，但还没有获得CPU时间片段时处于就绪状态。
• 运行(Running): 当线程获得了CPU时间片段并且正在执行时处于运行状态。
• 阻塞(Blocked): 当线程在等待某个资源或锁时处于阻塞状态。
• 死亡(Dead): 当线程的run方法执行完毕或调用了stop()方法时处于死亡状态。

一个线程在创建后，会经历以下过程：

• 新建状态 -> 就绪状态 -> 运行状态 -> 阻塞状态 -> 运行状态 -> ... -> 死亡状态

线程的同步与互斥

Java线程提供了多种同步机制来避免线程之间的数据竞争和冲突。

1. synchronized关键字

synchronized关键字可以修饰方法或代码块，实现对共享资源的同步访问。当线程进入被synchronized修饰的方法或代码块时，会获取该对象的锁，其他线程只能等待释放锁后才能进入。这样可以确保同一时间只有一个线程可以访问共享资源。

public class Counter {
    private int count;

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

2. ReentrantLock类

ReentrantLock是Java中的一个可重入锁，提供了更灵活的线程同步机制。与synchronized相比，ReentrantLock提供了更多的控制选项，例如可指定公平性、获取锁的超时时间等。

import java.util.concurrent.locks.ReentrantLock;

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

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
}

线程间的通信

Java线程可以通过以下几种方式进行通信：

1. 共享内存

多个线程可以通过访问相同的内存区域来进行通信。共享内存的方式简单直接，但需要考虑线程安全问题，如使用同步机制保护共享资源。

2. 消息传递

线程可以通过传递消息来进行通信，如使用wait()、notify()和notifyAll()方法实现线程间的通知和等待。

class Message {
    private String content;
    private boolean available = false;

    public synchronized String take() {
        while (!available) {
            try {
                wait(); // 当前线程等待
            } catch (InterruptedException e) {
                // 处理异常
            }
        }
        available = false;
        notifyAll(); // 唤醒其他线程
        return content;
    }

    public synchronized void put(String content) {
        while (available) {
            try {
                wait(); // 当前线程等待
            } catch (InterruptedException e) {
                // 处理异常
            }
        }
        this.content = content;
        available = true;
        notifyAll(); // 唤醒其他线程
    }
}

线程池

线程池是一种重用线程的机制，可以避免频繁创建和销毁线程的开销。Java线程池框架提供了Executor和ExecutorService两个接口，用于管理线程池的创建、执行和销毁。

import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;

public class Main {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 10; i++) {
            executor.execute(new MyRunnable());
        }
        executor.shutdown();
    }
}

以上是Java线程的基本介绍，涵盖了线程的创建、状态与生命周期、同步与互斥、线程间通信和线程池的内容。使用线程可以提高程序的并发性能和响应速度，但需要注意线程安全问题和资源竞争。