java 线程如何执行

线程创建与启动

在Java中，线程可以通过继承Thread类或实现Runnable接口来创建。继承Thread类需要重写run()方法，而实现Runnable接口需要实现run()方法。创建线程实例后，调用start()方法启动线程。

// 继承Thread类
class MyThread extends Thread {
    public void run() {
        System.out.println("Thread running");
    }
}

// 实现Runnable接口
class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Runnable running");
    }
}

// 启动线程
MyThread thread1 = new MyThread();
thread1.start();

Runnable runnable = new MyRunnable();
Thread thread2 = new Thread(runnable);
thread2.start();

线程状态管理

Java线程有六种状态：NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING和TERMINATED。通过Thread.getState()可以获取线程当前状态。线程状态转换由JVM调度控制，开发者可通过wait()、notify()、join()等方法干预。

Thread thread = new Thread(() -> {
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
});
System.out.println(thread.getState()); // NEW
thread.start();
System.out.println(thread.getState()); // RUNNABLE

线程同步与锁

多线程共享资源时需使用同步机制避免竞态条件。Java提供synchronized关键字和java.util.concurrent.locks包实现同步。synchronized可修饰方法或代码块，确保同一时间只有一个线程执行临界区代码。

class Counter {
    private int count = 0;

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

// 使用ReentrantLock
import java.util.concurrent.locks.ReentrantLock;

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

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

线程池的使用

Java通过ExecutorService框架提供线程池管理。常用线程池包括FixedThreadPool、CachedThreadPool和ScheduledThreadPool。线程池可减少线程创建销毁开销，提高资源利用率。

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

ExecutorService executor = Executors.newFixedThreadPool(4);
for (int i = 0; i < 10; i++) {
    executor.execute(() -> {
        System.out.println("Task executed by " + Thread.currentThread().getName());
    });
}
executor.shutdown();

线程间通信

线程可通过共享对象或使用wait()/notify()机制通信。BlockingQueue等并发容器是线程安全的高效通信工具。生产者-消费者模式是典型应用场景。

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);

// 生产者
new Thread(() -> {
    try {
        queue.put(1);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}).start();

// 消费者
new Thread(() -> {
    try {
        Integer item = queue.take();
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}).start();

线程中断处理

线程可通过interrupt()方法请求中断，被中断线程需检查isInterrupted()状态并响应。正确处理中断是编写健壮多线程程序的关键。

Thread worker = new Thread(() -> {
    while (!Thread.currentThread().isInterrupted()) {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
});
worker.start();
worker.interrupt();