详解JUC并发编程中的进程与线程学习

详解JUC并发编程中的进程与线程学习攻略

一、进程与线程的概念及区别

• 进程：是指正在执行的程序的实例。每个进程都有独立的内存空间，它可以包括多个线程。

• 线程：是指程序中独立、并发执行的最小单位，它直接依赖于进程，一个进程可以创建多个线程。

进程与线程的最大区别在于进程是资源分配的最小单位，线程是CPU调度的最小单位。线程共享进程的内存空间以及其他系统资源。

二、JUC（java.util.concurrent）并发编程的基本概念

JUC是Java中并发编程的核心类库，包含并发编程的基本概念：锁、原子操作、线程池和并发工具类等。

1.锁

常用的几种锁包括：synchronized锁、ReentrantLock锁和StampedLock锁等。锁的作用是为了解决多个线程对公共数据的访问产生的并发问题。

示例1：synchronized锁的用法

public class SyncExample {
    private int count = 0;

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

    public static void main(String[] args) throws InterruptedException {
        SyncExample example = new SyncExample();
        for (int i = 0; i < 1000; i++) {
            new Thread(() -> example.increase()).start();
        }
        Thread.sleep(5000); // 等待所有线程执行完毕
        System.out.println(example.count);
    }
}

示例2：ReentrantLock锁的用法

import java.util.concurrent.locks.ReentrantLock;

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

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

    public static void main(String[] args) throws InterruptedException {
        LockExample example = new LockExample();
        for (int i = 0; i < 1000; i++) {
            new Thread(() -> example.increase()).start();
        }
        Thread.sleep(5000); // 等待所有线程执行完毕
        System.out.println(example.count);
    }
}

2.原子操作

原子操作是指可由线程安全地执行的操作，常见的原子操作包括：AtomicInteger、AtomicLong等。

示例3：AtomicInteger的用法

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicExample {
    private AtomicInteger count = new AtomicInteger(0);

    public void increase() {
        count.incrementAndGet();
    }

    public static void main(String[] args) throws InterruptedException {
        AtomicExample example = new AtomicExample();
        for (int i = 0; i < 1000; i++) {
            new Thread(() -> example.increase()).start();
        }
        Thread.sleep(5000); // 等待所有线程执行完毕
        System.out.println(example.count.get());
    }
}

3.线程池

线程池可以复用线程，避免创建和销毁线程所带来的开销，从而提高程序性能。

示例4：线程池的用法

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

public class ThreadPoolExample {
    private int count = 0;
    private final ExecutorService threadPool = Executors.newFixedThreadPool(10);

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

    public void test() {
        for (int i = 0; i < 1000; i++) {
            threadPool.submit(() -> increase());
        }
        threadPool.shutdown();
        try {
            threadPool.awaitTermination(1, TimeUnit.HOURS); // 等待所有线程执行完毕
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(count);
    }

    public static void main(String[] args) {
        new ThreadPoolExample().test();
    }
}

总结

通过学习JUC并发编程中的进程与线程，我们可以更好地理解多线程编程的原理，更加熟练地应用JUC中提供的并发工具，在实际开发中更好地满足业务需求。