java如何实现线程

线程的实现方式

在Java中，线程的实现主要通过继承Thread类或实现Runnable接口来完成。以下是两种主要方法的详细说明。

继承Thread类

通过继承Thread类并重写run()方法，可以创建自定义线程。线程启动时，run()方法中的逻辑会被执行。

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread running by extending Thread class");
    }
}

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

实现Runnable接口

实现Runnable接口是更推荐的方式，因为它避免了单继承的限制，且更符合面向对象的设计原则。实现Runnable接口后，需要将其实例传递给Thread类的构造函数。

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Thread running by implementing Runnable interface");
    }
}

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

使用Lambda表达式简化

Java 8及更高版本支持Lambda表达式，可以进一步简化Runnable接口的实现。

public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            System.out.println("Thread running using Lambda expression");
        });
        thread.start();
    }
}

线程池的使用

为了高效管理线程资源，可以使用线程池。ExecutorService提供了线程池的实现。

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

public class Main {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(5);
        executor.submit(() -> {
            System.out.println("Task executed by thread pool");
        });
        executor.shutdown();
    }
}

线程的生命周期

线程的生命周期包括新建（New）、就绪（Runnable）、运行（Running）、阻塞（Blocked）和终止（Terminated）状态。通过Thread类的方法可以控制线程的状态转换。

线程同步

多线程环境下，共享资源的访问需要通过同步机制来保证线程安全。常用的同步方式包括synchronized关键字和Lock接口。

class Counter {
    private int count = 0;

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

    public int getCount() {
        return count;
    }
}

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

线程间通信

线程间可以通过wait()、notify()和notifyAll()方法实现通信。这些方法必须在同步块或同步方法中调用。

class SharedResource {
    private boolean ready = false;

    public synchronized void produce() {
        ready = true;
        notify();
    }

    public synchronized void consume() {
        while (!ready) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("Resource consumed");
    }
}

public class Main {
    public static void main(String[] args) {
        SharedResource resource = new SharedResource();
        Thread producer = new Thread(resource::produce);
        Thread consumer = new Thread(resource::consume);
        consumer.start();
        producer.start();
    }
}

线程的优先级

线程的优先级可以通过setPriority(int priority)方法设置，优先级范围从1（最低）到10（最高）。默认优先级为5。

Thread thread = new Thread(() -> {
    System.out.println("Thread with priority running");
});
thread.setPriority(Thread.MAX_PRIORITY);
thread.start();

通过以上方法，可以灵活地在Java中实现和管理线程，满足多线程编程的需求。