java中线程间的通信机制

1，通道

在进程中，可以通过管道的方式进行通信，在java线程中，也是可以通过管道的方式进行通信的。如一些文件的上传，可以直接在内存中通过管道的方式进行文件的上传，而不需要先将文件落盘到本地，再将文件上传到ftp服务器上，通过减少写入磁盘这一步骤，从而提高文件的上传效率，减少硬件和资源等的成本。

java中实现管道输入和输出的方式主要有四种，分别是PipedOutputStream、PipedInputStream、PipedReader 和 PipedWriter 。前面两种主要是针对二进制的字节流，后面两种主要是针对文本的字符流。

//构建输入流
PipedReader pipedReader = new PipedReader();
//构建输出流
PipedWriter pipedWriter = new PipedWriter();
try {
    //建立连接
    pipedReader.connect(pipedWriter);
} catch (IOException e) {
    e.printStackTrace();
}

并且在高并发中，这些管道流的操作都是属于线程安全的。

join

在日常开发中，比如说存在三个线程，分别是t1，t2，t3这三个线程，需求是想让t2在t1执行完后再执行，t3想再t2执行完后再执行。由于java中采用的是抢占式的线程调度方式，即不能手动的去操控线程的执行状况，因此在后面就出现了这个join 的方式。如下面的代码

public static void main(String[] args){
     Thread t1 = new Thread(new Runnable() {
         @Override
         public void run() {
             try {
                 //休眠2s
                 Thread.sleep(2000);
                 System.out.println(Thread.currentThread().getName());
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     },"t1");
     Thread t2 = new Thread(new Runnable() {
         @Override
         public void run() {
             try {
                 //加入join
                 t1.join();
                 System.out.println(Thread.currentThread().getName());
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     },"t2");
     t1.start();
     t2.start();
 }

可以通过执行结果发现线程t2需要在t1执行完成之后，才会继续执行。

synchronized

在jvm中，每个线程都会对应一个虚拟机栈中的栈帧，里面存在操作数栈，局部变量表等，每个线程中的内部参数是线程安全的，但是如果存在一个全局变量，会通过多个线程去操作，那么就会出现不可预料的后果，就是所谓的线程安全的问题。

因此在java中引入了一种阻塞状态，就是通过这个synchronized关键字，来解决多个线程操作一个全局变量可能出现的不可预料的问题。这种关键字可以加载方法上，也可以加在对象的同步块上面。这种方式相当于把并发的访问变成了串行的访问。

//对象锁加在方法上
public synchronized void countAdd(){count++;}
//对象锁加在同步块上
synchronized(this){count++}
//类锁加在静态方法上
public synchronized static void countAdd(){count++;}
//类锁加在其他对象上
synchronized(object){count++}

volatile

上面谈到了这个synchronized关键字，但是在java中该关键字属于重量级操作，有可能要对操作系统进行调度，从用户态到内核态之间来回的切换等，因此就出现了一个轻量级操作的关键字 volatile。

该关键字可以保证不同线程对某个变量操作的即时可见性，即某一个线程一旦将某个变量的值给改了，那么其他线程是立马可以感应到的。

如下面这段代码，同时开启一个main主线程和一个子线程，在主线程中将变量的值改了，如果变量不加这个volatile关键字，那么子线程将会一直卡住进入死循环，如果变量加了这个volatile关键字，子线程就可以立马的感受到其他线程修改了这个变量的值，从而获取到修改后的值，跳出循环

/**
 * @author zhenghuisheng
 * @date : 2023/7/28
 */
public class VolatileTest {
    private static volatile boolean flag = false;
    private static volatile int count = 0;

    public static class InnerTest extends Thread{
        @Override
        public void run() {
            while (!flag){

            }
            System.out.println("当前线程不阻塞了，count值为：" + count);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //开启线程
        new InnerTest().start();
        //休眠一段时间，让子线程空转一会
        Thread.sleep(2000);
        //主线程将数据替换
        flag = true;
        count = 100;
        //替换完成之后，子线程立马感知看到这个修改的数据
        Thread.sleep(2000);
        System.out.println("main主线程执行完毕");
    }
}

volatile不是一把真正的锁，所以不能保证数据的原子性，即如果在高并发情况下在变量上使用该关键字，会出现安全问题。该关键字主要适用的场景是：一个线程读、多个线程写