Go语言视频零基础入门到精通

admin

之所以会用到同步，是因为如果多个线程中对同一个资源进行操作时，会发生混乱。
比如2个线程对变量进行加1操作，第1个线程还没来的及改写数据时，第2个线程就对变量进行操作了，那变量最终的结果就是未知的，这个时候就需要同步来进行控制了。
例子如下：

1. <?php
3. class Count extends Thread
4. {
5.     public $cnt = 0;
7.     public function run()
8.     {
9.         $this->add();
10.     }
12.     public function add()
13.     {
14.         //对成员进行加1操作
15.         for ($i = 0; $i < 100000; $i++) {
16.             ++$this->cnt;
17.         }
18.     }
19. }
21. $c = new Count();
22. //调用start()时，线程run()中就调用了add()方法
23. $c->start();
24. //我们人为再调用一次add()方法，这时候就会有两个for循环对$cnt进行操作
25. $c->add();
26. //把创建的线程加入主线程中，让主线程等待子线程运行结束
27. $c->join();
29. //这里输出就是不确定性的
30. var_dump($c->cnt);

复制代码

多次运行后，$cnt的值是不确定的。如下图所示：

在pthreads v2中我们可以用Mutex，不过在v3版本中被删除了，所以我们可以简单的把加1操作放到synchronized中进行同步，代码如下：

1. <?php
3. class Count extends Thread
4. {
5.     public $cnt = 0;
7.     public function run()
8.     {
9.         $this->add();
10.     }
12.     public function add()
13.     {
14.         $this->synchronized(function () {
15.             //对成员进行加1操作
16.             for ($i = 0; $i < 100000; $i++) {
17.                 ++$this->cnt;
18.             }
19.         });
20.     }
21. }
23. $c = new Count();
24. //调用start()时，线程run()中就调用了add()方法
25. $c->start();
26. //我们人为再调用一次add()方法，这时候就会有两个for循环对$cnt进行操作
27. $c->add();
28. //把创建的线程加入主线程中，让主线程等待子线程运行结束
29. $c->join();
31. //这里就会一直输出200000
32. var_dump($c->cnt);

复制代码

结果如下所示：

当然我们也可以通过notify()和wait()进行同步控制，代码如下：

1. <?php
3. class Task extends Thread
4. {
5.     public $flag = 1;
7.     public function run()
8.     {
9.         $this->synchronized(function () {
10.             //标识不为1就一直等待
11.             if ($this->flag !== 1) {
12.                 $this->wait();
13.             }
15.             for ($i = 1; $i <= 10; $i++) {
17.                 echo "flag : {$this->flag} i : {$i} \n";
19.                 if ($this->flag === 1) {
20.                     //设置标识
21.                     $this->flag = 2;
22.                     //发送唤醒通知，然后让当前线程等待
23.                     //注意，notify()与wait()顺序不要搞错了，不然会一直阻塞
24.                     $this->notify();
25.                     $this->wait();
26.                 }
27.             }
29.             //我们在这里再次调用notify()
30.             //因为在最后一次输出flag : 2 i : 20时，当前线程的i已经变成11了，跳出了for循环，
31.             //但另一个线程则一直阻塞在wait()那里，程序无法结束，所以需要notify()再次唤醒一次
32.             $this->notify();
33.         });
34.     }
35. }
37. $t = new Task();
38. $t->start();
40. $t->synchronized(function ($obj) {
41.     //标识不为2就一直等待
42.     if ($obj->flag !== 2) {
43.         $obj->wait();
44.     }
46.     for ($i = 11; $i <= 20; $i++) {
48.         echo "flag : {$obj->flag} i : {$i} \n";
50.         if ($obj->flag === 2) {
51.             $obj->flag = 1;
52.             $obj->notify();
53.             $obj->wait();
54.         }
55.     }
56. }, $t);
58. //把创建的线程加入主线程中，让主线程等待子线程运行结束
59. $t->join();

复制代码

结果如下图所示：

我们通过notify()和wait()控制了两个for循环，来回的输出变量i的值，保证了顺序性。
我们再来看一个复杂点的例子，共享的资源，如果不进行同步操作，会出现不可预知的情况，代码如下：  

1. <?php
3. class Task extends Thread
4. {
5.     private $name;
6.     private $file;
8.     public function __construct($name, $file)
9.     {
10.         $this->name = $name;
11.         $this->file = $file;
12.     }
14.     public function run()
15.     {
16.         $data = file_get_contents($this->file);
17.         $data = floatval($data);
18.         for ($i = 0; $i < 100000; $i++) {
19.             ++$data;
20.         }
21.         file_put_contents($this->file, $data);
22.         echo "task : {$this->name} data : {$data} \n";
23.     }
24. }
26. $tasks = [];
27. $file = "./test.log";
29. for ($i = 0; $i < 100; $i++) {
30.     $tasks[$i] = new Task($i, $file);
31.     $tasks[$i]->start();
32. }
34. for ($i = 0; $i < 100; $i++) {
35.     $tasks[$i]->join();
36. }

复制代码

我们开100个线程对文件test.log进行读写，理想状态下，test.log中的数据应该是每次增加10000000的。现在的电脑配置都比较好，大家可以多运行几次就可以看出效果。

很明显最后的数据好像少了200000，多线程下对test.log文件进行读写，而我们又没有加锁，显然是会出现数据混乱的。
现在我们修改一下代码，如下：

1. <?php
3. class File extends Thread
4. {
5.     private $file;
7.     public function __construct($file)
8.     {
9.         $this->file = $file;
10.     }
12.     public function inc()
13.     {
14.         //进行同步控制，当100个task线程调用inc方法时，synchronized可以保证块内的代码是同步的
15.         //注意，注意，不要把inc方法写到Task里，那样是没效果的，因为每个task线程都是独立空间，他们各自调各自的inc方法，是没法做到同步的
16.         //常用的做法是我们要同步哪些资源，就为这些资源写个Thread类，并提供操作这些资源的方法，并在方法里加上synchronized
17.         return $this->synchronized(function () {
18.             $data = file_get_contents($this->file);
19.             $data = floatval($data);
20.             for ($i = 0; $i < 100000; $i++) {
21.                 ++$data;
22.             }
23.             file_put_contents($this->file, $data);
24.             return $data;
25.         });
26.     }
27. }
29. class Task extends Thread
30. {
31.     private $name;
32.     private $file;
34.     public function __construct($name, $file)
35.     {
36.         $this->name = $name;
37.         $this->file = $file;
38.     }
40.     public function run()
41.     {
42.         $data = $this->file->inc();
43.         echo "task : {$this->name} data : {$data} \n";
44.     }
45. }
47. $tasks = [];
48. $file = new File("./test.log");
50. for ($i = 0; $i < 100; $i++) {
51.     $tasks[$i] = new Task($i, $file);
52.     $tasks[$i]->start();
53. }
55. for ($i = 0; $i < 100; $i++) {
56.     $tasks[$i]->join();
57. }

复制代码

结果如下图所示，当然为了保险起见，我们可以试着多运行几次，下面是我运行了25次的结果：