Java中的内存模型(JMM)和锁机制详解

public class counter {
    private int count = 0;

    // 使用synchronized修饰方法，确保线程安全
    public synchronized void increment() {
        count++; // 这是一个非原子操作，但在synchronized方法中它是安全的
    }

    public synchronized int getcount() {
        return count;
    }

    public static void main(string[] args) throws interruptedexception {
        final counter counter = new counter();

        // 创建两个线程来更新计数器
        thread t1 = new thread(() -> {
            for (int i = 0; i < 10000; i++) {
                counter.increment();
            }
        });

        thread t2 = new thread(() -> {
            for (int i = 0; i < 10000; i++) {
                counter.increment();
            }
        });

        // 启动线程
        t1.start();
        t2.start();

        // 等待线程完成
        t1.join();
        t2.join();

        // 打印最终计数器值
        system.out.println("final count: " + counter.getcount()); // 应该是20000
    }
}

public class volatileexample {
    // 使用volatile修饰共享变量，确保所有线程都能看到最新的值
    private volatile boolean running = true;

    // 启动一个线程来模拟运行中的任务
    public void starttask() {
        thread taskthread = new thread(() -> {
            while (running) {
                // 模拟任务执行，这里只是简单地打印信息
                system.out.println("task is running...");
                try {
                    // 为了演示，让线程暂停一段时间
                    thread.sleep(1000);
                } catch (interruptedexception e) {
                    thread.currentthread().interrupt(); // 保持中断状态
                    return;
                }
            }
            system.out.println("task has stopped.");
        });

        // 启动线程
        taskthread.start();

        // 假设在一段时间后，我们想要停止任务
        try {
            thread.sleep(5000); // 等待5秒来模拟任务运行时间
        } catch (interruptedexception e) {
            thread.currentthread().interrupt();
            return;
        }

        // 更新volatile变量以停止任务
        running = false;
    }

    public static void main(string[] args) {
        volatileexample example = new volatileexample();
        example.starttask();

        // 注意：在实际应用中，你可能需要等待taskthread真正结束，这里为了简化示例而省略了
    }
}

public class waitnotifyexample {
    private final object lock = new object(); // 锁对象
    private boolean ready = false; // 条件变量

    // 生产者线程调用此方法
    public void produce() throws interruptedexception {
        synchronized (lock) {
            // 假设生产者需要做一些准备工作
            system.out.println("producer is preparing...");
            thread.sleep(1000); // 模拟耗时操作

            // 准备工作完成，设置条件变量并通知等待的消费者
            ready = true;
            lock.notify(); // 唤醒等待在该锁上的一个线程
            system.out.println("product is ready. notified consumer.");
        }
    }

    // 消费者线程调用此方法
    public void consume() throws interruptedexception {
        synchronized (lock) {
            // 等待产品准备好
            while (!ready) {
                lock.wait(); // 释放锁并进入等待状态
            }

            // 产品已准备好，开始消费
            system.out.println("consumer is consuming the product.");
            thread.sleep(1000); // 模拟消费过程

            // 消费完成，重置条件变量供下一轮使用
            ready = false;
        }
    }

    public static void main(string[] args) {
        waitnotifyexample example = new waitnotifyexample();

        // 创建生产者线程
        thread producer = new thread(() -> {
            try {
                example.produce();
            } catch (interruptedexception e) {
                thread.currentthread().interrupt();
            }
        });

        // 创建消费者线程
        thread consumer = new thread(() -> {
            try {
                example.consume();
            } catch (interruptedexception e) {
                thread.currentthread().interrupt();
            }
        });

        // 启动线程
        producer.start();
        consumer.start();

        // 注意：在这个简单的示例中，没有等待消费者线程完成。
        // 在实际应用中，你可能需要某种形式的同步来确保生产者和消费者之间的正确交互。
    }
}

import java.util.concurrent.locks.lock;
import java.util.concurrent.locks.reentrantlock;

public class counterwithlock {
    private int count = 0;
    private final lock lock = new reentrantlock();

    public void increment() {
        lock.lock(); // 获取锁
        try {
            count++;
        } finally {
            lock.unlock(); // 释放锁，无论是否发生异常
        }
    }

    public int getcount() {
        lock.lock(); // 这里也可以考虑使用trylock()或读写锁等更细粒度的控制
        try {
            return count;
        } finally {
            lock.unlock();
        }
    }

    // main方法和上面的示例类似，只是counter类被替换为了counterwithlock类
}

import java.util.concurrent.locks.condition;
import java.util.concurrent.locks.lock;
import java.util.concurrent.locks.reentrantlock;

public class conditionexample {
    private final lock lock = new reentrantlock();
    private final condition condition = lock.newcondition();
    private boolean ready = false;

    // 线程执行的任务
    public void task() throws interruptedexception {
        lock.lock(); // 获取锁
        try {
            // 等待条件满足
            while (!ready) {
                condition.await(); // 释放锁并进入等待状态
            }

            // 条件满足，执行任务
            system.out.println("condition met, task is executing.");

            // 假设任务完成后需要重置条件
            ready = false;
        } finally {
            lock.unlock(); // 无论如何，最后都要释放锁
        }
    }

    // 触发条件的方法
    public void triggercondition() {
        lock.lock(); // 获取锁
        try {
            ready = true; // 设置条件为true
            condition.signalall(); // 唤醒所有等待该条件的线程
        } finally {
            lock.unlock(); // 释放锁
        }
    }

    public static void main(string[] args) {
        conditionexample example = new conditionexample();

        // 创建并启动线程
        thread thread = new thread(() -> {
            try {
                example.task();
            } catch (interruptedexception e) {
                thread.currentthread().interrupt();
            }
        });

        thread.start();

        // 主线程等待一会儿，然后触发条件
        try {
            thread.sleep(1000); // 等待一秒，模拟其他操作
        } catch (interruptedexception e) {
            thread.currentthread().interrupt();
        }

        example.triggercondition(); // 触发条件，唤醒等待的线程
    }
}

import java.util.concurrent.semaphore;

public class semaphoreexample {
    // 创建一个semaphore对象，设置许可数量为2
    // 这意味着同时最多只能有两个线程可以访问资源
    private final semaphore semaphore = new semaphore(2);

    // 模拟的资源访问方法
    public void accessresource() {
        try {
            // 请求许可
            semaphore.acquire();
            system.out.println(thread.currentthread().getname() + " has acquired a permit and is accessing the resource.");

            // 模拟资源访问的耗时操作
            thread.sleep(1000);

            // 访问完成后，释放许可
            semaphore.release();
            system.out.println(thread.currentthread().getname() + " has released the permit.");
        } catch (interruptedexception e) {
            thread.currentthread().interrupt(); // 保持中断状态
            system.out.println(thread.currentthread().getname() + " was interrupted while accessing the resource.");
        }
    }

    public static void main(string[] args) {
        semaphoreexample example = new semaphoreexample();

        // 创建并启动多个线程来访问资源
        for (int i = 0; i < 5; i++) {
            new thread(() -> {
                example.accessresource();
            }, "thread-" + (i + 1)).start();
        }
    }
}

import java.util.concurrent.countdownlatch;
import java.util.concurrent.executorservice;
import java.util.concurrent.executors;

public class countdownlatchexample {

    public static void main(string[] args) throws interruptedexception {
        // 创建一个countdownlatch实例，设置计数器的初始值为2
        // 这意味着我们需要等待两个任务完成
        countdownlatch latch = new countdownlatch(2);

        // 创建一个线程池来执行任务
        executorservice executor = executors.newfixedthreadpool(2);

        // 提交第一个任务
        executor.submit(() -> {
            try {
                // 模拟任务执行
                system.out.println("task 1 is running");
                thread.sleep(1000); // 假设任务需要1秒来完成
                system.out.println("task 1 is done");
            } catch (interruptedexception e) {
                thread.currentthread().interrupt();
            } finally {
                // 任务完成后，计数器的值减1
                latch.countdown();
            }
        });

        // 提交第二个任务
        executor.submit(() -> {
            try {
                // 模拟任务执行
                system.out.println("task 2 is running");
                thread.sleep(2000); // 假设这个任务需要2秒来完成
                system.out.println("task 2 is done");
            } catch (interruptedexception e) {
                thread.currentthread().interrupt();
            } finally {
                // 任务完成后，计数器的值减1
                latch.countdown();
            }
        });

        // 等待直到所有任务完成
        latch.await(); // 这会阻塞当前线程，直到计数器的值变为0

        // 关闭线程池
        executor.shutdown();

        // 所有任务都已完成，继续执行后续操作
        system.out.println("all tasks are completed.");
    }
}

import java.util.concurrent.brokenbarrierexception;
import java.util.concurrent.cyclicbarrier;

public class cyclicbarrierexample {

    // 创建一个cyclicbarrier对象，设置屏障点需要等待的线程数量为3
    // 第二个参数是一个runnable对象，它是当所有线程都到达屏障点时会执行的任务（可选）
    private final cyclicbarrier barrier = new cyclicbarrier(3, () -> {
        system.out.println("all threads have reached the barrier. barrier is now broken.");
    });

    public void task() {
        // 模拟任务执行前的准备工作
        try {
            // 假设每个线程都需要一些时间来准备
            thread.sleep((long) (math.random() * 1000));
            system.out.println(thread.currentthread().getname() + " is ready.");

            // 等待直到所有线程都到达屏障点
            barrier.await();

            // 所有线程都到达屏障点后，继续执行后续任务
            system.out.println(thread.currentthread().getname() + " is continuing after the barrier.");
        } catch (interruptedexception | brokenbarrierexception e) {
            e.printstacktrace();
        }
    }

    public static void main(string[] args) {
        cyclicbarrierexample example = new cyclicbarrierexample();

        // 创建并启动三个线程来执行任务
        for (int i = 1; i <= 3; i++) {
            new thread(() -> {
                example.task();
            }, "thread-" + i).start();
        }
    }
}