Java并发编程之线程之间的共享和协作

Java并发编程是一种多线程编程的方式，线程之间的共享和协作是非常重要的一部分。本文将从以下几个方面进行详细讲解：

1. 线程的共享变量
2. 线程的同步与协作
3. 示例说明

线程的共享变量

多个线程可以同时访问一个变量，这个变量称为共享变量。必须确保线程之间访问共享变量是安全的，否则会产生线程安全问题。Java提供了一些机制来确保共享变量的线程安全，最常用的就是synchronized关键字和Lock接口。

线程的同步与协作

线程同步是指多个线程按照一定的顺序执行，以避免并发问题。线程同步需要使用一些机制来保证多个线程之间的执行顺序，常用的机制有synchronized关键字、ReentrantLock、Semaphore等。

线程协作是指多个线程之间的配合完成一项任务。线程协作需要使用一些机制来保证不同线程之间的顺序和互动，常用的机制有wait()、notify()、await()、signal()等。

示例说明

以下是两个示例，分别演示了线程的同步和协作机制。

示例1：线程同步

假设有两个线程T1和T2，它们都要向同一个账户中存款。如果它们同时执行，那么就会造成数据不一致的问题。

public class BankAccount {
    private int balance;

    public synchronized void deposit(int amount) {
        balance += amount;
    }

    public synchronized int getBalance() {
        return balance;
    }
}

public class DepositRunnable implements Runnable {
    private BankAccount account;
    private int amount;

    public DepositRunnable(BankAccount account, int amount) {
        this.account = account;
        this.amount = amount;
    }

    public void run() {
        account.deposit(amount);
    }
}

public class Main {
    public static void main(String[] args) {
        BankAccount account = new BankAccount();
        Thread t1 = new Thread(new DepositRunnable(account, 100));
        Thread t2 = new Thread(new DepositRunnable(account, 200));
        t1.start();
        t2.start();
        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(account.getBalance());
    }
}

在示例1中，我们通过synchronized关键字来确保多线程访问共享变量时的线程安全。

示例2：线程协作

假设有两个线程T1和T2，它们需要交替打印0-100的数字。

public class Main {
    public static void main(String[] args) {
        Object lock = new Object();

        Thread t1 = new Thread(new Runnable() {
            public void run() {
                synchronized (lock) {
                    for (int i = 0; i <= 100; i += 2) {
                        System.out.println(i);
                        lock.notify();
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    lock.notify();
                }
            }
        });

        Thread t2 = new Thread(new Runnable() {
            public void run() {
                synchronized (lock) {
                    for (int i = 1; i <= 100; i += 2) {
                        System.out.println(i);
                        lock.notify();
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    lock.notify();
                }
            }
        });

        t1.start();
        t2.start();
        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在示例2中，我们通过wait()和notify()方法来实现线程的协作，确保T1和T2能够交替打印0-100的数字。

以上就是Java并发编程之线程之间的共享和协作的完整攻略，希望对大家有所帮助。