Julia集图像渲染被并发破坏了。

huangapple
go评论118阅读模式
英文:

Julia set image rendering ruined by concurrency

问题

这段代码的变化导致图像看起来非常不同。图案基本相同，但是出现了许多之前不存在的白色像素。

这是因为你在Julia()函数中使用了并发操作。通过使用go关键字创建了一个匿名函数作为goroutine，在每个像素点上都启动了一个goroutine来计算对应的n值并设置像素颜色。

然而，这种并发操作可能导致竞争条件。由于goroutine的执行是异步的，它们可能会同时访问和修改共享的img对象。这可能导致图像数据的不一致性，从而产生了额外的白色像素。

为了解决这个问题，你可以使用互斥锁（mutex）来保护对img对象的并发访问。在每个goroutine中，使用互斥锁来确保每次只有一个goroutine能够修改img对象。这样可以避免竞争条件，保证图像数据的一致性。

另外，你还需要在主函数中等待所有的goroutine执行完毕，可以使用sync.WaitGroup来实现。在每个goroutine启动之前，调用wg.Add(1)增加等待组的计数器，然后在goroutine结束时调用wg.Done()减少计数器。最后，使用wg.Wait()等待所有的goroutine执行完毕。

下面是修改后的代码示例：

  1. import (
  2. 	"sync"
  3. )
  5. func Julia(f ComplexFunc, n int) image.Image {
  6. 	bounds := image.Rect(-n/2, -n/2, n/2, n/2)
  7. 	img := image.NewRGBA(bounds)
  8. 	s := float64(n / 4)
  9. 	var wg sync.WaitGroup
  10. 	var mutex sync.Mutex
  12. 	for i := bounds.Min.X; i < bounds.Max.X; i++ {
  13. 		for j := bounds.Min.Y; j < bounds.Max.Y; j++ {
  14. 			wg.Add(1)
  15. 			go func(i, j int) {
  16. 				defer wg.Done()
  17. 				n := Iterate(f, complex(float64(i)/s, float64(j)/s), 256)
  18. 				r := uint8(0)
  19. 				g := uint8(0)
  20. 				b := uint8(n % 32 * 8)
  21. 				mutex.Lock()
  22. 				img.Set(i, j, color.RGBA{r, g, b, 255})
  23. 				mutex.Unlock()
  24. 			}(i, j)
  25. 		}
  26. 	}
  28. 	wg.Wait()
  29. 	return img
  30. }

通过添加互斥锁和等待组，你可以确保并发操作的安全性，并消除额外的白色像素。

英文:

I have the following code that I am to change into a concurrent program.

  1. // Stefan Nilsson 2013-02-27
  3. // This program creates pictures of Julia sets (en.wikipedia.org/wiki/Julia_set).
  4. package main
  6. import (
  7. 	&quot;image&quot;
  8. 	&quot;image/color&quot;
  9. 	&quot;image/png&quot;
  10. 	&quot;log&quot;
  11. 	&quot;math/cmplx&quot;
  12. 	&quot;os&quot;
  13. 	&quot;strconv&quot;
  14. )
  16. type ComplexFunc func(complex128) complex128
  18. var Funcs []ComplexFunc = []ComplexFunc{
  19. 	func(z complex128) complex128 { return z*z - 0.61803398875 },
  20. 	func(z complex128) complex128 { return z*z + complex(0, 1) },
  21. }
  23. func main() {
  24. 	for n, fn := range Funcs {
  25. 		err := CreatePng(&quot;picture-&quot;+strconv.Itoa(n)+&quot;.png&quot;, fn, 1024)
  26. 		if err != nil {
  27. 			log.Fatal(err)
  28. 		}
  29. 	}
  30. }
  32. // CreatePng creates a PNG picture file with a Julia image of size n x n.
  33. func CreatePng(filename string, f ComplexFunc, n int) (err error) {
  34. 	file, err := os.Create(filename)
  35. 	if err != nil {
  36. 		return
  37. 	}
  38. 	defer file.Close()
  39. 	err = png.Encode(file, Julia(f, n))
  40. 	return
  41. }
  43. // Julia returns an image of size n x n of the Julia set for f.
  44. func Julia(f ComplexFunc, n int) image.Image {
  45. 	bounds := image.Rect(-n/2, -n/2, n/2, n/2)
  46. 	img := image.NewRGBA(bounds)
  47. 	s := float64(n / 4)
  48. 	for i := bounds.Min.X; i &lt; bounds.Max.X; i++ {
  49. 		for j := bounds.Min.Y; j &lt; bounds.Max.Y; j++ {
  50. 			n := Iterate(f, complex(float64(i)/s, float64(j)/s), 256)
  51. 			r := uint8(0)
  52. 			g := uint8(0)
  53. 			b := uint8(n % 32 * 8)
  54. 			img.Set(i, j, color.RGBA{r, g, b, 255})
  55. 		}
  56. 	}
  57. 	return img
  58. }
  60. // Iterate sets z_0 = z, and repeatedly computes z_n = f(z_{n-1}), n &#226;‰&#165; 1,
  61. // until |z_n| &gt; 2  or n = max and returns this n.
  62. func Iterate(f ComplexFunc, z complex128, max int) (n int) {
  63. 	for ; n &lt; max; n++ {
  64. 		if real(z)*real(z)+imag(z)*imag(z) &gt; 4 {
  65. 			break
  66. 		}
  67. 		z = f(z)
  68. 	}
  69. 	return
  70. }

I have decided to try and make the Julia() function concurrent. So I changed it to:

  1. func Julia(f ComplexFunc, n int) image.Image {	
  2. 	bounds := image.Rect(-n/2, -n/2, n/2, n/2) 	
  3. 	img := image.NewRGBA(bounds)				
  4. 	s := float64(n / 4)							 
  5. 	for i := bounds.Min.X; i &lt; bounds.Max.X; i++ {
  6. 		for j := bounds.Min.Y; j &lt; bounds.Max.Y; j++ {
  7. 			go func(){
  8. 				n := Iterate(f, complex(float64(i)/s, float64(j)/s), 256)
  9. 				r := uint8(0)	
  10. 				g := uint8(0)	
  11. 				b := uint8(n % 32 * 8)	
  12. 				img.Set(i, j, color.RGBA{r, g, b, 255}) 
  13. 			}()
  14. 		}
  15. 	}
  16. 	return img

This change causes the images to look very different. The patterns are essentially the same, but there are a lot of white pixels that were not there before.

What is happening here?

答案1

得分: 0

有两个问题：

  1. 你实际上没有等待 goroutine 完成。
  2. 你没有将 i 和 j 传递给 goroutine，所以它们几乎总是最后的 i 和 j。

你的函数应该类似于：

  1. func Julia(f ComplexFunc, n int) image.Image {
  2.     var wg sync.WaitGroup
  3.     bounds := image.Rect(-n/2, -n/2, n/2, n/2)
  4.     img := image.NewRGBA(bounds)
  5.     s := float64(n / 4)
  6.     for i := bounds.Min.X; i < bounds.Max.X; i++ {
  7.         for j := bounds.Min.Y; j < bounds.Max.Y; j++ {
  8.             wg.Add(1)
  9.             go func(i, j int) {
  10.                 n := Iterate(f, complex(float64(i)/s, float64(j)/s), 256)
  11.                 r := uint8(0)
  12.                 g := uint8(0)
  13.                 b := uint8(n % 32 * 8)
  14.                 img.Set(i, j, color.RGBA{r, g, b, 255})
  15.                 wg.Done()
  16.             }(i, j)
  17.         }
  18.     }
  19.     wg.Wait()
  20.     return img
  21. }

一个额外的提示，在并发编程中，通常使用 race detector 来测试你的代码是一个好主意。

你可能需要使用互斥锁来调用 img.Set，但我不太确定，而且我现在无法测试。

英文:

There are 2 problems:

  1. You don't actually wait for your goroutines to finish.
  2. You don't pass i and j to the goroutine, so they will almost always be the last i and j.

Your function should look something like:

  1. func Julia(f ComplexFunc, n int) image.Image {
  2. 	var wg sync.WaitGroup
  3. 	bounds := image.Rect(-n/2, -n/2, n/2, n/2)
  4. 	img := image.NewRGBA(bounds)
  5. 	s := float64(n / 4)
  6. 	for i := bounds.Min.X; i &lt; bounds.Max.X; i++ {
  7. 		for j := bounds.Min.Y; j &lt; bounds.Max.Y; j++ {
  8. 			wg.Add(1)
  9. 			go func(i, j int) {
  10. 				n := Iterate(f, complex(float64(i)/s, float64(j)/s), 256)
  11. 				r := uint8(0)
  12. 				g := uint8(0)
  13. 				b := uint8(n % 32 * 8)
  14. 				img.Set(i, j, color.RGBA{r, g, b, 255})
  15. 				wg.Done()
  16. 			}(i, j)
  17. 		}
  18. 	}
  19. 	wg.Wait()
  20. 	return img
  21. }

A bonus tip, when diving into concurrency, it's usually a good idea to try your code with the race detector.

You might have to use a mutex to call img.Set but I'm not very sure and I can't test atm.

huangapple
  • 本文由 发表于 2016年4月11日 22:11:36
  • 转载请务必保留本文链接：https://go.coder-hub.com/36551154.html
  • concurrency
  • go
  • image
  • rendering
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定