Java共享内容通信 VS Golang通信共享内存

接触的编程语言从C到Java再到现在Go，每个语言都有其独有特性，也具备共通之处。
最近在学习并发编程的时候，发现一个很有意思的点：Java基于共享共享内存通信，而Golang则是通过通信共享内存。为什么？下面我们一起一探究竟！

1、Java内存模型

JMM（Java Memory Model），定义共享内存中多线程读写操作的行为规范，通过规则来规范对内存的读写操作从而保证指令正确性。
（1）JMM把内存分为两块：一块是私有线程的工作区域（工作内存）、一块是所有线程的共享区域（主内存）
（2）线程跟线程之间是相互隔离的，线程跟线程交互需要通过主内存

所以多个线程可以在同一个进程中共享数据，线程通过读取和写入共享变量来实现数据共享和通信。
不过由于竞态条件和数据竞争，需要使用同步机制（synchronized、lock接口）来实现线程间的同步互斥

2、Go CSP模型

CSP（Communicating Sequential Process）通信顺序进程，强调通过通道（channel）在多个并发执行的进程或线程之间进行通信和同步。
在Go中让goroutine通过channel来间接的共享内存，避免直接操作共享内存可能带来的竞态条件和数据竞争问题。
具体表现为：（1）当需要数据共享时，goroutine将数据发送通道；（2）另一goroutine从通道中接收数据，所以数据在goroutine之间的传递时通过明确通信操作完成的，而不是直接通过访问共享内存。

3、代码表现形式

使用Java和Go分别实现交替打印奇数和偶数来加深理解
（1）Java通过全局变量lock、isTurn来控制线程交替
（2）Go通过channel通信来实现协程交替打印

3.1、Java交替打印

package August.demo;

/**
 * 双线程交替打印
 * @Author: ChenZhiHui
 * @DateTime: 2024/8/24 00:37
 **/
public class ThreadPrint {

    public static Object lock = new Object();
    public static boolean isTurn = true;


    public static void main(String[] args) {
        Thread thread1 = new Thread(new PrintA());
        Thread thread2 = new Thread(new PrintB());
        thread1.start();
        thread2.start();
    }

    static class PrintA implements Runnable {
        @Override
        public void run() {
            for (int i = 1; i <= 9; i += 2) {
                synchronized (lock) {
                    while (!isTurn) {
                        try {
                            lock.wait();
                        } catch (InterruptedException exception) {
                            Thread.currentThread().interrupt();
                        }
                    }
                    System.out.println(Thread.currentThread() + " = " + i);
                    isTurn = false;
                    lock.notify();
                }
            }
        }
    }

    static class PrintB implements Runnable {
        @Override
        public void run() {
            for (int i = 2; i <= 10; i += 2) {
                synchronized (lock) {
                    while (isTurn) {
                        try {
                            lock.wait();
                        } catch (InterruptedException exception) {
                            Thread.currentThread().interrupt();
                        }
                    }
                    System.out.println(Thread.currentThread() + " = " + i);
                    isTurn = true;
                    lock.notify();
                }
            }
        }
    }
}

3.2、Go交替打印

package main

import (
 "fmt"
 "sync"
)

func main() {
 	chan01 := make(chan struct{}, 1)
 	chan02 := make(chan struct{}, 1)
 	var wg sync.WaitGroup
 	wg.Add(2)

	go func() {
  		defer wg.Done()
  		for i := 1; i <= 9; i += 2 {
   		<-chan01
   		fmt.Println("协程1 =", i)
   		chan02 <- struct{}{}
  		}
 	}()

	go func() {
	  defer wg.Done()
	  for i := 2; i <= 10; i += 2 {
	  	<-chan02
	   	fmt.Println("协程2 =", i)
	   	chan01 <- struct{}{} // 初次发送信号给协程1
	  }
	}()

	 // 启动协程
	 chan01 <- struct{}{}
	 wg.Wait()

}

4、总结

本文简单的描述Go和Java在通信和共享内存协作形式，通过简单的代码展示其设计思想，在实现代码的时候。有个小插曲，在Go实现交替打印的时候，出现了我们经常谈及的死锁，下一篇文章可以讲讲关于同步机制中需要避免产生死锁的注意点。