JAVA实现多线程间通讯的方法

JAVA是一门支持多线程的编程语言，多个线程之间可以并发执行任务，而且线程之间还可以通过通信机制来进行协调和同步，以达到更高的程序效率和灵活性。

下面介绍几种JAVA实现多线程间通讯的方法：

1. wait()和notify()机制

wait()和notify()是JAVA中线程通讯机制中最基本的方法，它们需要与synchronized关键字一起使用，保证线程安全。wait()方法使线程进入挂起状态，notify()方法则可以唤醒一个等待的线程。

下面是一个实例：

public class ShareData { 
    private int flag = 1; 
    public synchronized void print1() { 
        while (flag != 1) { 
            try { 
                wait(); 
            } catch (InterruptedException e) { 
                e.printStackTrace(); 
            } 
        } 
        System.out.println("Hello "); 
        flag = 2; 
        notify(); 
    } 

    public synchronized void print2() { 
        while (flag != 2) { 
            try { 
                wait(); 
            } catch (InterruptedException e) { 
                e.printStackTrace(); 
            } 
        } 
        System.out.println("World!"); 
        flag = 1; 
        notify(); 
    } 
} 

public class Thread1 extends Thread { 
    private ShareData shareData; 

    public Thread1(ShareData shareData) { 
        this.shareData = shareData; 
    } 

    @Override 
    public void run() { 
        super.run(); 
        while (true) { 
            shareData.print1(); 
            try { 
                Thread.sleep(1000); 
            } catch (InterruptedException e) { 
                e.printStackTrace(); 
            } 
        } 
    } 
} 

public class Thread2 extends Thread { 
    private ShareData shareData; 

    public Thread2(ShareData shareData) { 
        this.shareData = shareData; 
    } 

    @Override 
    public void run() { 
        super.run(); 
        while (true) { 
            shareData.print2(); 
            try { 
                Thread.sleep(1000); 
            } catch (InterruptedException e) { 
                e.printStackTrace(); 
            } 
        } 
    } 
} 

public class Test1 { 
    public static void main(String[] args) { 
        ShareData shareData = new ShareData(); 
        new Thread1(shareData).start(); 
        new Thread2(shareData).start(); 
    } 
}

运行结果：

Hello

World!

Hello

World!

Hello

World!

2. Lock和Condition机制

Lock和Condition是JAVA中线程通讯机制中另外一种比wait()和notify()更灵活、更高效的方法，可以根据需要唤醒多个线程。

下面是一个实例：

import java.util.concurrent.locks.Condition; 
import java.util.concurrent.locks.Lock; 
import java.util.concurrent.locks.ReentrantLock; 

public class ShareData2 { 
    private int flag = 1; 
    private Lock lock = new ReentrantLock(); 
    private Condition condition1 = lock.newCondition(); 
    private Condition condition2 = lock.newCondition(); 

    public void print1() { 
        lock.lock(); 
        try { 
            while (flag != 1) { 
                try { 
                    condition1.await(); 
                } catch (InterruptedException e) { 
                    e.printStackTrace(); 
                } 
            } 
            System.out.println("Hello "); 
            flag = 2; 
            condition2.signal(); 
        } finally { 
            lock.unlock(); 
        } 
    } 

    public void print2() { 
        lock.lock(); 
        try { 
            while (flag != 2) { 
                try { 
                    condition2.await(); 
                } catch (InterruptedException e) { 
                    e.printStackTrace(); 
                } 
            } 
            System.out.println("World!"); 
            flag = 1; 
            condition1.signal(); 
        } finally { 
            lock.unlock(); 
        } 
    } 
} 

public class Thread3 extends Thread { 
    private ShareData2 shareData; 

    public Thread3(ShareData2 shareData) { 
        this.shareData = shareData; 
    } 

    @Override 
    public void run() { 
        super.run(); 
        while (true) { 
            shareData.print1(); 
            try { 
                Thread.sleep(1000); 
            } catch (InterruptedException e) { 
                e.printStackTrace(); 
            } 
        } 
    } 
} 

public class Thread4 extends Thread { 
    private ShareData2 shareData; 

    public Thread4(ShareData2 shareData) { 
        this.shareData = shareData; 
    } 

    @Override 
    public void run() { 
        super.run(); 
        while (true) { 
            shareData.print2(); 
            try { 
                Thread.sleep(1000); 
            } catch (InterruptedException e) { 
                e.printStackTrace(); 
            } 
        } 
    } 
} 

public class Test2 { 
    public static void main(String[] args) { 
        ShareData2 shareData = new ShareData2(); 
        new Thread3(shareData).start(); 
        new Thread4(shareData).start(); 
    } 
}

运行结果：

Hello

World!

Hello

World!

Hello

World!

3. BlockingQueue机制

BlockingQueue是JAVA并发包中提供的一种线程安全的、支持多线程通讯的队列。它可以很方便地实现生产者-消费者模式，在多线程环境下实现通讯和同步。

下面是一个实例：

import java.util.concurrent.BlockingQueue; 
import java.util.concurrent.LinkedBlockingQueue; 

public class ShareData3 { 
    private BlockingQueue<String> queue = new LinkedBlockingQueue<>(1); 

    public void print1() { 
        try { 
            queue.put("Hello "); 
            System.out.print("Hello "); 
        } catch (InterruptedException e) { 
            e.printStackTrace(); 
        } 
    } 

    public void print2() { 
        try { 
            queue.take(); 
            System.out.println("World!"); 
        } catch (InterruptedException e) { 
            e.printStackTrace(); 
        } 
    } 
} 

public class Thread5 extends Thread { 
    private ShareData3 shareData; 

    public Thread5(ShareData3 shareData) { 
        this.shareData = shareData; 
    } 

    @Override 
    public void run() { 
        super.run(); 
        while (true) { 
            shareData.print1(); 
            try { 
                Thread.sleep(1000); 
            } catch (InterruptedException e) { 
                e.printStackTrace(); 
            } 
        } 
    } 
} 

public class Thread6 extends Thread { 
    private ShareData3 shareData; 

    public Thread6(ShareData3 shareData) { 
        this.shareData = shareData; 
    } 

    @Override 
    public void run() { 
        super.run(); 
        while (true) { 
            shareData.print2(); 
            try { 
                Thread.sleep(1000); 
            } catch (InterruptedException e) { 
                e.printStackTrace(); 
            } 
        } 
    } 
} 

public class Test3 { 
    public static void main(String[] args) { 
        ShareData3 shareData = new ShareData3(); 
        new Thread5(shareData).start(); 
        new Thread6(shareData).start(); 
    } 
}

运行结果：

Hello World!

Hello World!

Hello World!

综上所述，实现多线程间通讯的方法众多，开发人员需要根据具体需求选择合适的方式。在使用的过程中，保证线程安全是非常重要的，需要遵循良好的编程规范，避免出现死锁、竞争等问题。