带你快速搞定Java多线程

Java多线程是Java编程中非常重要的一个主题。多线程是指一个程序有多个线程同时进行，不仅可以提高程序的运行效率，还可以充分发挥多核CPU的优势。在本文中，我们将介绍Java多线程相关的基础知识和实践。

基本概念

• 线程：一个进程中的单个执行线程，它可以独立执行并拥有自己的状态、堆栈和局部变量
• 进程：正在运行的程序实例
• 并发：多个线程同时执行，但不一定是同时完成
• 并行：多个线程同时执行，并同时完成

创建线程

Java提供了两种创建线程的方式：
* 继承Thread类：新建一个类继承Thread，重写run方法，通过调用start()启动线程
* 实现Runnable：实现Runnable接口，实现run方法，创建Thread对象并将Runnable实例作为参数传递给Thread对象的构造函数

继承Thread类

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

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

实现Runnable接口

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

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

线程同步

在多线程程序中，由于多个线程共享内存，可能会产生数据不一致的问题。Java提供了几种实现线程同步的机制：

• synchronized：可以修饰方法或代码块，保证它们的原子性（同一时刻只能被一个线程访问）
• volatile：可以修饰变量，保证线程之间的可见性（当一个线程修改该变量后，会及时通知到其他线程）
• Lock：可以替代synchronized来实现更细粒度的同步控制

synchronized同步示例

class Counter {
    private int count;

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

    public int getCount() {
        return count;
    }
}

public class SynchronizedDemo {
    public static void main(String[] args) throws InterruptedException {
        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();

        thread1.join();
        thread2.join();

        System.out.println(counter.getCount()); // 期望结果: 2000
    }
}

volatile同步示例

class MyRunnable implements Runnable {
    private volatile boolean isRunning = true;

    public void stopRunning() {
        this.isRunning = false;
    }

    @Override
    public void run() {
        while (isRunning) {
            // do something...
        }
    }
}

public class VolatileDemo {
    public static void main(String[] args) throws InterruptedException {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();

        // 3秒后停止线程
        Thread.sleep(3000);
        myRunnable.stopRunning();
    }
}

线程池

线程池是为了解决线程开销和资源调度问题而提出的一种技术方案，用于管理和复用多个线程。在Java中，线程池的实现可以通过调用Executors类中的各个静态工厂方法来完成。

public class ThreadPoolDemo {
    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 10; i++) {
            threadPool.execute(() -> {
                System.out.println(Thread.currentThread().getName() + " is running...");
            });
        }
        threadPool.shutdown();
    }
}

总结

Java多线程是一门非常重要的技术，本文介绍了Java多线程的基础概念，线程创建和同步的示例，以及线程池的使用。通过学习本文，您应该对Java多线程有了更全面的了解。