13518219792
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((char) 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 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();
}
}
