Java线程同步的实现方法

在多线程编程中，线程同步是必不可少的一个概念。线程同步指的是多个线程访问共享资源时的控制问题。Java提供了多种实现线程同步的方法，这篇文章将从多个方面对线程同步的实现方法进行详细阐述。

一、synchronized关键字

Java中的synchronized关键字是实现线程同步的最基本的方法。synchronized关键字可以将方法或代码块标记为同步的，从而保证同一时刻只有一个线程可以访问被保护的方法或代码块，避免多个线程同时对共享资源进行访问。

public class SyncTest implements Runnable {
 
    private synchronized void myMethod() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " print " + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
 
    @Override
    public void run() {
        myMethod();
    }
 
    public static void main(String[] args) {
        SyncTest test = new SyncTest();
        Thread thread1 = new Thread(test);
        Thread thread2 = new Thread(test);
        thread1.start();
        thread2.start();
    }
}

上面的例子中，myMethod方法被标记为synchronized，因此在同一时刻只有一个线程可以执行myMethod方法中的代码块。运行该程序可以看到两个线程交替输出数字。

二、使用Lock接口

Java 5引入了Lock接口，Lock接口提供了和synchronized关键字相同的功能，但是可以更加灵活地控制同步代码块的粒度。对于需要更加灵活地控制同步代码块的情况，可以考虑使用Lock接口。

public class LockTest implements Runnable {
 
    private Lock lock = new ReentrantLock();
 
    private void myMethod() {
        lock.lock();
        try {
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName() + " print " + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        } finally {
            lock.unlock();
        }
    }
 
    @Override
    public void run() {
        myMethod();
    }
 
    public static void main(String[] args) {
        LockTest test = new LockTest();
        Thread thread1 = new Thread(test);
        Thread thread2 = new Thread(test);
        thread1.start();
        thread2.start();
    }
}

上面的例子中，使用ReentrantLock作为锁对象，通过调用lock方法和unlock方法进行同步。与synchronized关键字的方式相比，Lock接口提供了更加灵活的同步粒度控制。

三、使用wait、notify和notifyAll方法

Java中的Object类提供了wait、notify和notifyAll三个方法，这三个方法可以用于实现线程间的通信和同步。wait方法使得当前线程等待，直到其他线程调用notify或notifyAll方法唤醒它。notify方法唤醒单个正在等待的线程，而notifyAll方法唤醒所有正在等待的线程。

public class WaitNotifyTest {
 
    private static final Object lock = new Object();
 
    static class MyThread1 extends Thread {
        @Override
        public void run() {
            synchronized (lock) {
                System.out.println("Thread 1 is running...");
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread 1 is resumed...");
            }
        }
    }
 
    static class MyThread2 extends Thread {
        @Override
        public void run() {
            synchronized (lock) {
                System.out.println("Thread 2 is running...");
                lock.notify();
                System.out.println("Thread 2 is completed...");
            }
        }
    }
 
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new MyThread1();
        Thread thread2 = new MyThread2();
        thread1.start();
        Thread.sleep(1000);
        thread2.start();
    }
}

上面的例子中，使用wait和notify方法实现了两个线程之间的同步。Thread 1先获取了lock对象的锁，然后调用wait方法释放锁并等待，等待Thread 2调用lock对象的notify方法进行唤醒。Thread 2调用lock对象的notify方法唤醒了Thread 1。

四、使用Condition接口

Java 5引入了Condition接口，Condition接口是对wait、notify和notifyAll方法的升级版，可以让线程更加精细地控制等待和通知的颗粒度。和Lock接口一样，Condition接口可以更加灵活地控制同步代码块的粒度。

public class ConditionTest {
 
    private Lock lock = new ReentrantLock();
 
    private Condition condition = lock.newCondition();
 
    private void myMethod() throws InterruptedException {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + " await...");
            condition.await();
            System.out.println(Thread.currentThread().getName() + " resumed...");
        } finally {
            lock.unlock();
        }
    }
 
    public void signal() throws InterruptedException {
        lock.lock();
        try {
            System.out.println("Signal...");
            condition.signal();
        } finally {
            lock.unlock();
        }
    }
 
    public static void main(String[] args) throws InterruptedException {
        ConditionTest test = new ConditionTest();
        Thread thread1 = new Thread(() -> {
            try {
                test.myMethod();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        Thread thread2 = new Thread(() -> {
            try {
                test.signal();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        thread1.start();
        Thread.sleep(1000);
        thread2.start();
    }
}

上面的例子中，使用Condition接口实现线程间的同步。myMethod方法获取lock锁对象并等待条件变量，通过调用condition.await方法进行等待。signal方法获取lock锁对象并发出唤醒信号，通过调用condition.signal方法进行唤醒。通过使用Condition接口可以更加灵活地控制同步的粒度。

五、总结

本文对Java线程同步的实现方法进行了详细的阐述，包括synchronized关键字、Lock接口、wait、notify和notifyAll方法以及Condition接口。在多线程编程中，线程同步是一个非常重要的概念，合理地使用上述方法可以保证多个线程之间的正确协作。