java线程通信方式有几种

Java线程通信方式主要有以下几种：

1、共享内存

2、信号量

3、管道

4、消息队列

5、套接字

6、共享文件

7、信号

8、原子操作

9、wait/notify机制

下面我们将详细介绍这些线程通信方式。

共享内存

共享内存是多个线程共享同一块内存空间，通过读写共享变量来实现线程间的通信，这种方式简单易用，但需要注意同步问题，避免出现数据不一致的情况。

class SharedMemoryExample {    private static int sharedVar = 0;    public static void main(String[] args) {        Thread t1 = new Thread(() > {            for (int i = 0; i < 1000; i++) {                sharedVar++;            }        });        Thread t2 = new Thread(() > {            for (int i = 0; i < 1000; i++) {                sharedVar;            }        });        t1.start();        t2.start();        try {            t1.join();            t2.join();        } catch (InterruptedException e) {            e.printStackTrace();        }        System.out.println("sharedVar: " + sharedVar);    }}

信号量

信号量是一种用于控制多个线程对共享资源访问的计数器，当信号量值为正时，线程可以访问共享资源；当信号量值为负时，线程需要等待其他线程释放资源。

Java中可以使用Semaphore类实现信号量。

import java.util.concurrent.Semaphore;class SemaphoreExample {    private static Semaphore semaphore = new Semaphore(1);    public static void main(String[] args) {        Thread t1 = new Thread(() > {            try {                semaphore.acquire();                System.out.println("Thread 1 acquired the semaphore");                Thread.sleep(1000);                semaphore.release();                System.out.println("Thread 1 released the semaphore");            } catch (InterruptedException e) {                e.printStackTrace();            }        });        Thread t2 = new Thread(() > {            try {                semaphore.acquire();                System.out.println("Thread 2 acquired the semaphore");                semaphore.release();                System.out.println("Thread 2 released the semaphore");            } catch (InterruptedException e) {                e.printStackTrace();            }        });        t1.start();        t2.start();    }}

管道

管道是一种半双工的通信方式，数据只能在一个方向上流动，在Java中，可以使用PipedInputStream和PipedOutputStream类实现管道通信。

import java.io.IOException;import java.io.PipedInputStream;import java.io.PipedOutputStream;class PipeExample {    public static void main(String[] args) throws IOException {        PipedInputStream inputStream = new PipedInputStream();        PipedOutputStream outputStream = new PipedOutputStream();        outputStream.connect(inputStream);        Thread t1 = new Thread(() > {            try {                outputStream.write("Hello, world!".getBytes());                outputStream.close();            } catch (IOException e) {                e.printStackTrace();            }        });        Thread t2 = new Thread(() > {            try {                int data = inputStream.read();                while (data != 1) {                    System.out.print((ｃｈａｒ) data);                    data = inputStream.read();                }                inputStream.close();            } catch (IOException e) {                e.printStackTrace();            }        });        t1.start();        t2.start();    }}

消息队列

消息队列是一种先进先出（FIFO）的数据结构，用于存储线程间传递的消息，Java中可以使用BlockingQueue接口及其实现类（如LinkedBlockingQueue）实现消息队列。

import java.util.concurrent.BlockingQueue;import java.util.concurrent.LinkedBlockingQueue;class MessageQueueExample {    private static BlockingQueue<String> messageQueue = new LinkedBlockingQueue<>();    public static void main(String[] args) {        Thread t1 = new Thread(() > {            try {                messageQueue.put("Hello, world!");            } catch (InterruptedException e) {                e.printStackTrace();            }        });        Thread t2 = new Thread(() > {            try {                String message = messageQueue.take();                System.out.println("Received message: " + message);            } catch (InterruptedException e) {                e.printStackTrace();            }        });        t1.start();        t2.start();    }}

套接字

套接字（Socket）是一种基于网络的通信方式，可以在不同计算机上的线程之间进行通信，Java中可以使用Socket类和ServerSocket类实现套接字通信。

import java.io.IOException;import java.io.InputStream;import java.io.OutputStream;import java.net.ServerSocket;import java.net.Socket;class SocketExample {    public static void main(String[] args) throws IOException {        ServerSocket serverSocket = new ServerSocket(8080);        Socket socket = serverSocket.accept();        Thread t1 = new Thread(() > {            try {                InputStream inputStream = socket.getInputStream();                byte[] buffer = new byte[1024];                int bytesRead = inputStream.read(buffer);                System.out.println("Received message: " + new String(buffer, 0, bytesRead));                inputStream.close();            } catch (IOException e) {                e.printStackTrace();            }        });        Thread t2 = new Thread(() > {            try {                OutputStream outputStream = socket.getOutputStream();                outputStream.write("Hello, world!".getBytes());                outputStream.close();            } catch (IOException e) {                e.printStackTrace();            }        });        t1.start();        t2.start();    }}

共享文件

共享文件是指多个线程通过读写同一个文件来实现通信，这种方式适用于需要持久化数据的场合。

import java.io.BufferedReader;import java.io.BufferedWriter;import java.io.FileReader;import java.io.FileWriter;import java.io.IOException;class SharedFileExample {    private static final String FILE_NAME = "shared_file.txt";    public static void main(String[] args) throws IOException {        Thread t1 = new Thread(() > {            try (BufferedWriter writer = new BufferedWriter(new FileWriter(FILE_NAME))) {                writer.write("Hello, world!");            } catch (IOException e) {                e.printStackTrace();            }        });        Thread t2 = new Thread(() > {            try (BufferedReader reader = new BufferedReader(new FileReader(FILE_NAME))) {                String message = reader.readLine();                System.out.println("Received message: " + message);            } catch (IOException e) {                e.printStackTrace();            }        });        t1.start();        t2.start();    }}

信号

信号是一种异步通知机制，用于通知接收线程发生了某个事件，Java中可以使用Object类的wait()和notify()方法实现信号机制。

class SignalExample {    private static Object lock = new Object();    public static void main(String[] args) {        Thread t1 = new Thread(() > {            synchronized (lock) {                try {                    System.out.println("Thread 1 is waiting for a signal");                    lock.wait();                    System.out.println("Thread 1 received the signal");                } catch (InterruptedException e) {                    e.printStackTrace();                }            }        });        Thread t2 = new Thread(() > {            synchronized (lock) {                System.out.println("Thread 2 is sending a signal");                lock.notify();            }        });        t1.start();        t2.start();    }}

原子操作

原子操作是一种不可中断的操作，可以确保多个线程在访问共享资源时不会发生冲突，Java中可以使用AtomicInteger、AtomicLong等原子类实现原子操作。

import java.util.concurrent.atomic.AtomicInteger;class AtomicExample {    private static AtomicInteger atomicInt = new AtomicInteger(0);    public static void main(String[] args) {        Thread t1 = new Thread(() > {            for (int i = 0; i < 1000; i++) {                atomicInt.incrementAndGet();            }        });        Thread t2 = new Thread(() > {            for (int i = 0; i < 1000; i++) {                atomicInt.decrementAndGet();            }        });        t1.start();        t2.start();        try {            t1.join();            t2.join();        } catch (InterruptedException e) {            e.printStackTrace();        }        System.out.println("Atomic integer value: " + atomicInt.get());    }}

wait/notify机制

wait/notify机制是一种让线程等待某个条件满足后再继续执行的方法，Java中可以使用Object类的wait()和notify()方法实现wait/notify机制，这种机制通常与同步机制一起使用，以确保线程安全。

class WaitNotifyExample {    private static Object lock = new Object();    private static boolean condition = false;    public static void main(String[] args) {        Thread t1 = new Thread(() > {            synchronized (lock) {                while (!condition) {                    try {                        System.out.println("Thread 1 is waiting for the condition");                        lock.wait();                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                }                System.out.println("Thread 1 received the notification and condition is true");            }        });        Thread t2 = new Thread(() > {            synchronized (lock) {                condition = true;                System.out.println("Thread 2 is sending a notification");                lock.notify();            }        });        t1.start();        t2.start();    }}