Java开发中的并发编程

在多核CPU的时代，使用多线程编程已经是Java开发中的常态，对于并发编程的概念和实现方式有深入的了解是非常必要的。在Java中，实现并发编程有多种方式，包括使用Thread类、Runnable接口、线程池、锁等。本文将从几个方面介绍Java开发中的并发编程。

一、Thread类的使用

Java中的Thread类是实现多线程的基础，在使用时需要继承Thread类并重写run()方法，定义线程执行的代码。

public class MyThread extends Thread {
    @Override
    public void run() {
        // 线程执行的代码
        System.out.println("MyThread is running");
    }
}

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

上述代码中，定义了一个MyThread类继承自Thread类，重写了run()方法，线程启动时执行run()方法中的代码。

二、Runnable接口的使用

Runnable接口也是实现多线程的常用方式，在使用时需要实现run()方法，Runnable接口的实现类对象可以作为Thread类构造方法的参数，用于启动线程。

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        // 线程执行的代码
        System.out.println("MyRunnable is running");
    }
}

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

上述代码中，定义了一个MyRunnable类实现了Runnable接口并重写了run()方法，Runnable接口的实现类对象作为Thread类的构造方法参数，用于启动线程。

三、线程池的使用

线程池是一种同时管理多个线程的方式，将线程的创建和管理放在池中，可以有效减轻系统创建和删除线程的压力。Java中的线程池实现在java.util.concurrent包中，可以使用ThreadPoolExecutor类来创建线程池，此外还可以使用Executors类提供的方法简单创建线程池。

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        // 线程执行的代码
        System.out.println("MyRunnable is running");
    }
}

public class Demo {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 10; i++) {
            MyRunnable myRunnable = new MyRunnable();
            executorService.submit(myRunnable);
        }
        executorService.shutdown(); // 关闭线程池
    }
}

上述代码中，使用Executors类提供的方法创建一个固定线程数为5的线程池，并提交10个MyRunnable实例作为线程池的任务，最后关闭线程池。

四、锁的使用

在使用多线程时，需要注意线程安全的问题。Java中提供了多种锁机制来实现线程安全，常用的是synchronized关键字和ReentrantLock类。

使用synchronized关键字可以实现方法级别的锁，或者在代码块中使用synchronized(this)来实现对象级别的锁。

public class MyThread {
    private int count = 0;

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

    public synchronized int getCount() {
        return count;
    }
}

public class Demo {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        for (int i = 0; i  {
                for (int j = 0; j < 1000; j++) {
                    myThread.addCount();
                }
            }).start();
        }
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("count = " + myThread.getCount());
    }
}

上述代码中，使用synchronized关键字实现了对count属性的访问控制，确保了多线程环境下对count属性的数据同步。

使用ReentrantLock类也可以实现对共享资源的锁控制，ReentrantLock类实例在加锁后需要在finally中释放锁。

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

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

    public int getCount() {
        return count;
    }
}

public class Demo {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        for (int i = 0; i  {
                for (int j = 0; j < 1000; j++) {
                    myThread.addCount();
                }
            }).start();
        }
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("count = " + myThread.getCount());
    }
}

上述代码中，使用ReentrantLock类实现对count属性的访问控制，并且在finally块中释放锁。