java和go之间多线程之间的对比

最新推荐文章于 2025-04-17 10:43:54 发布

Cookie@513

最新推荐文章于 2025-04-17 10:43:54 发布

阅读量2k

点赞数 3

分类专栏： go

本文链接：https://blog.csdn.net/weixin_42353390/article/details/103669307

版权

go 专栏收录该内容

3 篇文章

订阅专栏

Java线程和go协程之间的对比

在Java中多线程之间是通过共享内存进行通信的，在go中多线程之间通信是基于消息的，go中的通道是go中多线程通信的基石。

在java中创建的线程是与OS线程一一对应的，而在go中多个协程（goroutine）对应一个逻辑处理器，每个逻辑处理器与OS线程一一对应。

每个线程要运行必须要在就绪状态情况下获取cpu，而操作系统是基于时间片轮转算法来调度线程占用cpu来执行任务的，每个OS线程被分配一个时间片来占用cpu进行任务的执行。

在java中由于创建的线程与os线程一一对应，所以java中的每个线程占用一个时间片来运行。而go中多个协程对应一个os 线程，也就是多个协程对应了一个时间片，go则使用自己的调度策略（非os的调度策略）来让多个协程使用一个时间片来并发的运行。也就是go中存在两级策略，一个是go语言层面的调度多个协程公用一个时间片，一个是os层面的调度多个逻辑处理器轮询占用不同的时间片。

多任务之间信号量的通信

samephore（java） ------ waitgroup (go)

public final static Semaphore SEMAPHORE = new Semaphore(0);
    public static void main(String[] args) throws InterruptedException {

        Thread thread1 = new Thread(() -> {

            try {
                //run method dosomthing
                System.out.println(Thread.currentThread().getName() + "done");
            }finally {
                SEMAPHORE.release();
            }
            
        },"thread-1");
        thread1.start();
        
        
        Thread thread2 = new Thread(() -> {

            try {
                //run method dosomthing
                System.out.println(Thread.currentThread().getName() + "done");

            }finally {
                SEMAPHORE.release();
            }
            
        },"thread-2");
        thread2.start();
        
        System.out.println("wait all sub thread end");
        SEMAPHORE.acquire(2);
        System.out.println("all sub thread end");

    }

//创建同步器
var wg sync.WaitGroup

func main() {
    //两个信号
    wg.Add(2)

    //开启一个协程，执行匿名函数里面的内容
    go func() {
        //信号量减去1
        defer wg.Done()

        //do somthing
        fmt.Println("im A go 协程")

    }()

    //开启一个协程，执行匿名函数里面的内容
    go func() {
        //信号量减去1
        defer wg.Done()

        //do somthing
        fmt.Println("im B go 协程")

    }()

    fmt.Println("wait all sub thread end")
    wg.Wait()
    fmt.Println(" all sub thread end")

}

GO的内存模型？？？未知

Go语言的内存模型规定了一个goroutine可以看到另外一个goroutine修改同一个变量的值的条件，这类似java内存模型中内存可见性问题;

Happen Before 原则

channel的happen-before原则

有缓冲的channel ，向channel中写入一个数据总是happen before 于这个这个数据从通道中读取完成

package main

import (
    "fmt"
)

var c = make(chan int, 10)
var a string

func f() {
    a = "hello, world" //1
    c <- 0             //2
}

func main() {
    go f()   //3
    <-c      //4
    fmt.Print(a) //5
}

关闭通道的操作 happen before 从通道接受0值（关闭通道后会向通道发送一个0值）

package main

import (
    "fmt"
)

var c = make(chan int, 10)
var a string

func f() {
    a = "hello, world" //1
    close(c)            //2
}

func main() {
    go f()   //3
    <-c      //4
    fmt.Print(a) //5
}

没有缓冲的channel，向通道中发送数据时必须确保通道中有接收的goroutine，所以通道中数据的接收Happen before 于数据的发送

package main

import (
    "fmt"
)

var c = make(chan int)
var a string

func f() {
    a = "hello, world" //1
    <-c                //2
}

func main() {
    go f()       //3
    c <- 0       //4
    fmt.Print(a) //5
}

限制goroutine的并发数量–利用有缓存的channel

package main

import (
    "fmt"
    "time"
)

var limit = make(chan int, 3)
 
func sayHello(index int){
    fmt.Println(index )
}

var work []func(int)
func main() {
    
    work := append(work,sayHello,sayHello,sayHello,sayHello,sayHello,sayHello)
    
    for i, w := range work {
        go func(w func(int),index int) {
            limit <- 1
            w(index)
            <-limit
        }(w,i)
    }
    
    time.Sleep(time.Second * 10)
}

goroutine限制并发量，每三个一个一组进行并发：原理 == 每一组接收完成之后才能再次进行写入；==
容量为C的通道接受第K个元素 happen before 向通道第k+C次写入完成，比如从容量为3的通道接受第2个元素 happen before 向通道第3+2次写入完成—也就是说开始写在接收完成之后

package main

import (
	"fmt"
	"time"
)

var limit = make(chan int, 3)

func sayHello(index int){
	fmt.Println(index )
}

var work []func(int)
func main() {

	work := append(work,sayHello,sayHello,sayHello,sayHello,sayHello,sayHello)

	a :=0
	//todo 这样会每三个一组进行并发执行
	//算是一个替空间的过程-也就是说  开始写 在 接收完成之后
	for i, s := range work {
		go func(s func(int),index int) {
			limit <- 1
			if a < 3{
				time.Sleep(time.Second * 1)
				s(1)
			}else{
				s(2)
			}
			a++
			<-limit

		}(s,i)
	}

	time.Sleep(time.Second * 3)
	test_a()
}

func test_a (){
	a:=0
	for i:=0;i<10;i++{
		go func() {
			for j := 0; j < 1000; j++ {
				a++
			}
		}()
	}

	time.Sleep(3*time.Second)
	fmt.Println(a)
}