Java底层并发：线程、volatile

news2024/11/18 2:52:57

在Java的并发编程中，线程、volatile关键字、原子性、临界区以及DelayQueue是一些重要概念。理解这些内容对于编写高效且线程安全的程序至关重要。

在这里插入图片描述

1. 线程的基本概念

Java中的线程是程序执行的最小单位。Java提供了多种创建线程的方式，最常用的方式是继承Thread类或实现Runnable接口。

示例代码

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

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

原理分析

线程的创建和管理是由JVM和操作系统共同完成的。JVM通过线程调度算法，决定哪个线程在什么时间执行。

2. volatile关键字

volatile关键字用于修饰变量，确保对该变量的读写操作是可见的。

示例代码

class VolatileExample {
    private volatile boolean running = true;

    public void run() {
        while (running) {
            // do something
        }
        System.out.println("Stopped");
    }

    public void stop() {
        running = false;
    }

    public static void main(String[] args) throws InterruptedException {
        VolatileExample example = new VolatileExample();
        Thread thread = new Thread(example::run);
        thread.start();

        // 让线程运行一段时间
        Thread.sleep(1000);
        example.stop();
    }
}

原理分析

使用volatile保证了变量的可见性，并禁止指令重排序，提升了并发效率。

3. 原子性

原子性是指一个操作要么全部完成，要么全部不执行。Java中可以通过Atomic类实现原子操作。

示例代码

import java.util.concurrent.atomic.AtomicInteger;

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

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

    public int getCount() {
        return count.get();
    }
}

public class Main {
    public static void main(String[] args) {
        AtomicExample example = new AtomicExample();
        example.increment();
        System.out.println("Count: " + example.getCount());
    }
}

原理分析

Atomic类使用CAS（Compare And Swap）算法实现原子性，避免了使用锁带来的性能损失。

4. 临界区

临界区是指访问共享资源的代码区域。通过synchronized关键字或显式锁来管理临界区。

示例代码

class CriticalSection {
    private int count = 0;

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

    public int getCount() {
        return count;
    }
}

原理分析

使用synchronized可以防止多个线程同时访问临界区，从而避免数据竞争，但可能导致性能瓶颈。

5. DelayQueue

DelayQueue是一个实现了BlockingQueue接口的队列，主要用于实现延迟任务。

示例代码

import java.util.concurrent.DelayQueue;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;

class DelayedItem implements Delayed {
    private final long delayTime;
    private final long expirationTime;

    public DelayedItem(long delayTime) {
        this.delayTime = delayTime;
        this.expirationTime = System.currentTimeMillis() + delayTime;
    }

    @Override
    public long getDelay(TimeUnit unit) {
        return unit.convert(expirationTime - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
    }

    @Override
    public int compareTo(Delayed o) {
        return Long.compare(this.expirationTime, ((DelayedItem) o).expirationTime);
    }
}

public class DelayQueueExample {
    public static void main(String[] args) throws InterruptedException {
        DelayQueue<DelayedItem> queue = new DelayQueue<>();
        queue.put(new DelayedItem(5000));

        System.out.println("Waiting for item...");
        DelayedItem item = queue.take(); // 等待5秒
        System.out.println("Item is taken after delay");
    }
}