PHP Swoole-Demo TCP服務端簡單實現

時間 2019-11-24

標籤 php swoole demo tcp 服務簡單實現欄目 PHP 简体版

原文原文鏈接

tcp 服務端簡單demo與client .

 1 <?php 
 2 /**
 3  * author : rookiejin <mrjnamei@gmail.com>
 4  * createTime : 2018/1/4 10:26
 5  * description: tcp.php - swoole-demo
 6  * 該代碼是一份簡單的面向對象形式的 tcp 服務器和客戶端通信的demo
 7  * 功能：實現服務器端tcp簡單demo
 8  */
 9 // 建立一個tcp服務器
10 
11 $server = new swoole_server("127.0.0.1", 9501);
12 
13 /**
14  * @var $server swoole_server
15  * @var $fd int 文件描述符
16  */
17 $server->on("connect", function($server , $fd){
18     echo "a client connected\n" ;
19 });
20 
21 /**
22  * @var $server swoole_server
23  * @var $fd int 文件描述符
24  * @var $from_id worker_id worker進程id
25  * @var $data 接受的數據
26  */
27 $server->on("receive", function($server , $fd , $from_id ,$data){
28     echo "#server received msg:" , $data , "\n";
29     $server->send($fd , "i received");
30 });
31 
32 /**
33  * @var $server swoole_server
34  * @var $fd 文件描述符
35  */
36 $server->on("close",function($server, $fd){
37     echo "# client closed\n";
38 });
39 // 啓動服務器
40 $server->start();
41 client.php
42 
43 <?php
44 
45 $client = new swoole_client(SWOOLE_SOCK_TCP);
46 
47 if(!$client->connect("127.0.0.1", 9501, -1)){
48     exit("connect failed" . $client->errCode . "\n");
49 }
50 
51 $client->send("helloworld");
52 echo $client->recv() , "\n";
53 $client->close();

2. 使用面向對象的方式來寫TCP服務器.php

  1 <?php
  2 /**
  3  * author : rookiejin <mrjnamei@gmail.com>
  4  * createTime : 2018/1/4 10:26
  5  * description: php_oop.php - swoole-demo
  6  * 該代碼是一份乾淨的tcp server 事件回調，
  7  * 沒有任何對事件回調的業務處理 .
  8  * 以該代碼爲基準，後面的demo都在此基礎上修改 .
  9  */
 10 
 11 class Server {
 12 
 13     /**
 14      * @var \swoole_server
 15      */
 16     public $server ;
 17 
 18     /**
 19      * 配置項
 20      * @var $config array
 21      */
 22     public $config ;
 23 
 24     /**
 25      * @var \Server
 26      */
 27     public static $_worker ;
 28 
 29     /**
 30      * 存儲pid文件的位置
 31      */
 32     public $pidFile ;
 33 
 34     /**
 35      * worker 進程的數量
 36      * @var $worker_num
 37      */
 38     public $worker_num;
 39 
 40     /**
 41      * 當前進程的worker_id
 42      * @var $worker_id
 43      */
 44     public $worker_id ;
 45 
 46     /**
 47      * task 進程數 + worker 進程數 = 總的服務進程
 48      * 給其餘的進程發送消息:
 49      * for($i = 0 ; $i < $count ; $i ++) {
 50      *    if($i == $this->worker_id)  continue;表示是該進程
 51      *    $this->server->sendMessage($i , $data);
 52      * }
 53      * task 進程的數量
 54      * @var $task_num
 55      */
 56     public $task_num ;
 57 
 58     /**
 59      * Server constructor.
 60      *
 61      * @param array $config
 62      */
 63     public function __construct(array $config)
 64     {
 65         $this->server = new swoole_server($config ['host'] , $config ['port']);
 66         $this->config = $config;
 67         $this->serverConfig();
 68         self::$_worker = & $this; // 引用
 69     }
 70 
 71     public function serverConfig()
 72     {
 73         $this->server->set($this->config['server']);
 74     }
 75 
 76     public function start()
 77     {
 78         // Server啓動在主進程的主線程回調此函數
 79         $this->server->on("start",[$this , "onSwooleStart"]);
 80         // 此事件在Server正常結束時發生
 81         $this->server->on("shutDown", [$this , "onSwooleShutDown"]);
 82         //事件在Worker進程/Task進程啓動時發生。這裏建立的對象能夠在進程生命週期內使用。
 83         $this->server->on("workerStart", [$this , "onSwooleWorkerStart"]);
 84         //  此事件在worker進程終止時發生。在此函數中能夠回收worker進程申請的各種資源。
 85         $this->server->on("workerStop",[$this, "onSwooleWorkerStop"]);
 86         // worker 向task_worker進程投遞任務觸發
 87         $this->server->on("task", [$this, "onSwooleTask"]);
 88         // task_worker 返回值傳給worker進程時觸發
 89         $this->server->on("finish",[$this , "onSwooleFinish"]);
 90         // 當工做進程收到由 sendMessage 發送的管道消息時會觸發onPipeMessage事件
 91         $this->server->on("pipeMessage",[$this ,"onSwoolePipeMessage"]);
 92         // 當worker/task_worker進程發生異常後會在Manager進程內回調此函數
 93         $this->server->on("workerError", [$this , "onSwooleWrokerError"]);
 94         // 當管理進程啓動時調用它，函數原型：
 95         $this->server->on("managerStart", [$this , "onSwooleManagerStart"]);
 96         // onManagerStop
 97         $this->server->on("managerStop", [$this , "onSwooleManagerStop"]);
 98         // 有新的鏈接進入時，在worker進程中回調。
 99         $this->server->on("connect" , [$this ,'onSwooleConnect']);
100         // 接收到數據時回調此函數，發生在worker進程中
101         $this->server->on("receive", [$this, 'onSwooleReceive']);
102         //CP客戶端鏈接關閉後，在worker進程中回調此函數。函數原型：
103         $this->server->on("close", [$this ,"onSwooleClose"]);
104         $this->server->start();
105     }
106 
107     /**
108      * @warning 進程隔離
109      * 該步驟通常用於存儲進程的 master_pid 和 manager_pid 到文件中
110      * 本例子存儲的位置是 __DIR__ . "/tmp/" 下面
111      * 能夠用 kill -15 master_pid 發送信號給進程關閉服務器，而且觸發下面的onSwooleShutDown事件
112      * @param $server
113      */
114     public function onSwooleStart($server)
115     {
116         $this->setProcessName('SwooleMaster');
117         $debug = debug_backtrace();
118         $this->pidFile = __DIR__ . "/temp/" . str_replace("/" , "_" , $debug[count($debug) - 1] ["file"] . ".pid" );
119         $pid = [$server->master_pid , $server->manager_pid];
120         file_put_contents($this->pidFile , implode(",", $pid));
121     }
122 
123     /**
124      * @param $server
125      * 已關閉全部Reactor線程、HeartbeatCheck線程、UdpRecv線程
126      * 已關閉全部Worker進程、Task進程、User進程
127      * 已close全部TCP/UDP/UnixSocket監聽端口
128      * 已關閉主Reactor
129      * @warning
130      * 強制kill進程不會回調onShutdown，如kill -9
131      * 須要使用kill -15來發送SIGTREM信號到主進程才能按照正常的流程終止
132      * 在命令行中使用Ctrl+C中斷程序會當即中止，底層不會回調onShutdown
133      */
134     public function onSwooleShutDown($server)
135     {
136         echo "shutdown\n";
137     }
138 
139     /**
140      * @warning 進程隔離
141      * 該函數具備進程隔離性 ,
142      * {$this} 對象從 swoole_server->start() 開始前設置的屬性所有繼承
143      * {$this} 對象在 onSwooleStart,onSwooleManagerStart中設置的對象屬於不一樣的進程中.
144      * 所以這裏的pidFile雖然在onSwooleStart中設置了，可是是不一樣的進程，因此找不到該值.
145      * @param \swoole_server $server
146      * @param int            $worker_id
147      */
148     public function onSwooleWorkerStart(swoole_server $server, int $worker_id)
149     {
150         if($this->isTaskProcess($server))
151         {
152             $this->setProcessName('SwooleTask');
153         }
154         else{
155             $this->setProcessName('SwooleWorker');
156         }
157         $debug = debug_backtrace();
158         $this->pidFile = __DIR__ . "/temp/" . str_replace("/" , "_" , $debug[count($debug) - 1] ["file"] . ".pid" );
159         file_put_contents($this->pidFile , ",{$worker_id}" , FILE_APPEND);
160     }
161 
162     public function onSwooleWorkerStop($server,$worker_id)
163     {
164         echo "#worker exited {$worker_id}\n";
165     }
166 
167     /**
168      * @warning 進程隔離 在task_worker進程內被調用
169      * worker進程可使用swoole_server_task函數向task_worker進程投遞新的任務
170      * $task_id和$src_worker_id組合起來纔是全局惟一的，不一樣的worker進程投遞的任務ID可能會有相同
171      * 函數執行時遇到致命錯誤退出，或者被外部進程強制kill，當前的任務會被丟棄，但不會影響其餘正在排隊的Task
172      * @param $server
173      * @param $task_id 是任務ID 由swoole擴展內自動生成，用於區分不一樣的任務
174      * @param $src_worker_id 來自於哪一個worker進程
175      * @param $data 是任務的內容
176      * @return mixed $data
177      */
178     public function onSwooleTask($server , $task_id, $src_worker_id,$data)
179     {
180         return $data ;
181     }
182 
183     public function onSwooleFinish()
184     {
185         
186     }
187 
188     /**
189      * 當工做進程收到由 sendMessage 發送的管道消息時會觸發onPipeMessage事件。worker/task進程均可能會觸發onPipeMessage事件。
190      * @param $server
191      * @param $src_worker_id 消息來自哪一個Worker進程
192      * @param $message 消息內容，能夠是任意PHP類型
193      */
194     public function onSwoolePipeMessage($server , $src_worker_id,$message)
195     {
196 
197     }
198 
199     /**
200      * worker進程發送錯誤的錯誤處理回調 .
201      * 記錄日誌等操做
202      * 此函數主要用於報警和監控，一旦發現Worker進程異常退出，那麼頗有多是遇到了致命錯誤或者進程CoreDump。經過記錄日誌或者發送報警的信息來提示開發者進行相應的處理。
203      * @param $server
204      * @param $worker_id 是異常進程的編號
205      * @param $worker_pid  是異常進程的ID
206      * @param $exit_code  退出的狀態碼，範圍是 1 ～255
207      * @param $signal 進程退出的信號
208      */
209     public function onSwooleWrokerError($server ,$worker_id,$worker_pid,$exit_code,$signal)
210     {
211         echo "#workerError:{$worker_id}\n";
212     }
213 
214     /**
215      *
216      */
217     public function onSwooleManagerStart()
218     {
219         $this->setProcessName('SwooleManager');
220     }
221 
222     /**
223      * @param $server
224      */
225     public function onSwooleManagerStop($server)
226     {
227         echo "#managerstop\n";
228     }
229 
230     /**
231      * 客戶端鏈接
232      * onConnect/onClose這2個回調發生在worker進程內，而不是主進程。
233      * UDP協議下只有onReceive事件，沒有onConnect/onClose事件
234      * @param $server
235      * @param $fd
236      * @param $reactorId
237      */
238     public function onSwooleConnect($server ,$fd ,$reactorId)
239     {
240         echo "#connected\n";
241     }
242 
243     /**
244      * @param $server server對象
245      * @param $fd 文件描述符
246      * @param $reactorId reactor線程id
247      */
248     public function onSwooleReceive($server,$fd,$reactorId)
249     {
250         echo "#received\n";
251     }
252 
253     /**
254      * 鏈接斷開，廣播業務須要從redis | memcached | 內存 中刪除該fd
255      * @param $server
256      * @param $fd
257      * @param $reactorId
258      */
259     public function onSwooleClose($server, $fd ,$reactorId)
260     {
261         echo "#swooleClosed\n" ;
262     }
263 
264     public function setProcessName($name)
265     {
266         if(function_exists('cli_set_process_title'))
267         {
268             @cli_set_process_title($name);
269         }
270         else{
271             @swoole_set_process_name($name);
272         }
273     }
274 
275     /**
276      * 返回真說明該進程是task進程
277      * @param $server
278      * @return bool
279      */
280     public function isTaskProcess($server)
281     {
282         return $server->taskworker === true ;
283     }
284 
285     /**
286      * main 運行入口方法
287      */
288     public static function main()
289     {
290         self::$_worker->start();
291     }
292 }
293 
294 $config = ['server' => ['worker_num' => 4 , "task_worker_num" => "20" , "dispatch_mode" => 3 ] , 'host' => '0.0.0.0' , 'port' => 9501];
295 $server = new Server($config);
296 Server::main() ;

本例子是註冊了swoole的基本事件監聽，回調沒有作，爲下面的代碼先作一份鋪墊。
這裏主要要講的是swoole的啓動步驟.

* note
1. $server = new Server ($config); 
在new了一個單例Server類之後，將Server::$_worker代理到自己$this. 而且作好服務器的配置. 2. Server::main(); 該代碼爲server註冊事件回調函數. 而後啓動 swoole_server::start();


3. 啓動過程：
 1). 先會開啓master進程. 觸發onSwooleStart事件，
     能夠獲取到master進程的pid和manager進程的pid.
     該函數式在master進程執行的.在事件回調裏實例化的任何對象只針對master進程有效.
 2). 接着觸發onSwooleManagerStart. 在manager進程中執行.
     該函數式在master進程執行的.在事件回調裏實例化的任何對象只針對manager進程有效.
 3). 接着觸發onSwooleWorkerStart. 該過程啓動worker與task_worker進程.步驟是並行的，
     不分前後. 
     worker進程與task_worker進程其實同樣，都屬於worker進程,具備進程隔離性，本身進程內
     實例化的類只有在本身進程內部有用，
     worker_num + worker_task_num = 總的worker_id數量. 
     若是須要從worker進程向其餘進程發送消息的話，能夠這麼作:

1    for($i = 0 ; $i < $worker_num + $task_worker_num ; $i ++) {
2         if($i == $this->worker_id) continue;
3         $this->server_sendMessage($i ,$message);
4      }

4). 而後監聽connect與receive事件, 就屬於具體的業務範疇了.

下面帶來一個 tcp 聊天室的簡單案例，例子是用swoole_table存儲全部的連接信息. 功能能夠實現羣聊，單聊: 主要業務邏輯在onSwooleReceive回調中react

  1 <?php
  2 /**
  3  * author : rookiejin <mrjnamei@gmail.com>
  4  * createTime : 2018/1/4 10:26
  5  * description: tcp_get_and_send.php - swoole-demo
  6  * 該代碼是一份簡單的面向對象形式的 tcp 服務器和客戶端通信的demo
  7  * 功能：單發.  羣發.
  8  */
  9 
 10 class Server {
 11 
 12     /**
 13      * @var \swoole_server
 14      */
 15     public $server ;
 16 
 17     /**
 18      * 配置項
 19      * @var $config array
 20      */
 21     public $config ;
 22 
 23     /**
 24      * @var \Server
 25      */
 26     public static $_worker ;
 27 
 28     /**
 29      * 存儲pid文件的位置
 30      */
 31     public $pidFile ;
 32 
 33     /**
 34      * worker 進程的數量
 35      * @var $worker_num
 36      */
 37     public $worker_num;
 38 
 39     /**
 40      * 當前進程的worker_id
 41      * @var $worker_id
 42      */
 43     public $worker_id ;
 44 
 45     /**
 46      * task 進程數 + worker 進程數 = 總的服務進程
 47      * 給其餘的進程發送消息:
 48      * for($i = 0 ; $i < $count ; $i ++) {
 49      *    if($i == $this->worker_id)  continue;表示是該進程
 50      *    $this->server->sendMessage($i , $data);
 51      * }
 52      * task 進程的數量
 53      * @var $task_num
 54      */
 55     public $task_num ;
 56 
 57     /**
 58      * @var $table swoole_table 內存表
 59      */
 60     public $table;
 61 
 62     /**
 63      * Server constructor.
 64      *
 65      * @param array $config
 66      */
 67     public function __construct(array $config)
 68     {
 69         $this->server = new swoole_server($config ['host'] , $config ['port']);
 70         $this->config = $config;
 71         $this->serverConfig();
 72         $this->createTable();
 73         self::$_worker = & $this; // 引用
 74     }
 75 
 76     private function serverConfig()
 77     {
 78         $this->server->set($this->config['server']);
 79     }
 80 
 81     /**
 82      * 建立swoole_table
 83      */
 84     private function createTable()
 85     {
 86         $this->table = new swoole_table( 65536 );
 87         $this->table->column("fd",swoole_table::TYPE_INT , 8);
 88         $this->table->column("worker_id", swoole_table::TYPE_INT , 4);
 89         $this->table->column("name",swoole_table::TYPE_STRING,255);
 90         $this->table->create();
 91     }
 92 
 93     public function start()
 94     {
 95         // Server啓動在主進程的主線程回調此函數
 96         $this->server->on("start",[$this , "onSwooleStart"]);
 97         // 此事件在Server正常結束時發生
 98         $this->server->on("shutDown", [$this , "onSwooleShutDown"]);
 99         //事件在Worker進程/Task進程啓動時發生。這裏建立的對象能夠在進程生命週期內使用。
100         $this->server->on("workerStart", [$this , "onSwooleWorkerStart"]);
101         //  此事件在worker進程終止時發生。在此函數中能夠回收worker進程申請的各種資源。
102         $this->server->on("workerStop",[$this, "onSwooleWorkerStop"]);
103         // worker 向task_worker進程投遞任務觸發
104         $this->server->on("task", [$this, "onSwooleTask"]);
105         // task_worker 返回值傳給worker進程時觸發
106         $this->server->on("finish",[$this , "onSwooleFinish"]);
107         // 當工做進程收到由 sendMessage 發送的管道消息時會觸發onPipeMessage事件
108         $this->server->on("pipeMessage",[$this ,"onSwoolePipeMessage"]);
109         // 當worker/task_worker進程發生異常後會在Manager進程內回調此函數
110         $this->server->on("workerError", [$this , "onSwooleWrokerError"]);
111         // 當管理進程啓動時調用它，函數原型：
112         $this->server->on("managerStart", [$this , "onSwooleManagerStart"]);
113         // onManagerStop
114         $this->server->on("managerStop", [$this , "onSwooleManagerStop"]);
115         // 有新的鏈接進入時，在worker進程中回調。
116         $this->server->on("connect" , [$this ,'onSwooleConnect']);
117         // 接收到數據時回調此函數，發生在worker進程中
118         $this->server->on("receive", [$this, 'onSwooleReceive']);
119         //CP客戶端鏈接關閉後，在worker進程中回調此函數。函數原型：
120         $this->server->on("close", [$this ,"onSwooleClose"]);
121         $this->server->start();
122     }
123 
124     /**
125      * @warning 進程隔離
126      * 該步驟通常用於存儲進程的 master_pid 和 manager_pid 到文件中
127      * 本例子存儲的位置是 __DIR__ . "/tmp/" 下面
128      * 能夠用 kill -15 master_pid 發送信號給進程關閉服務器，而且觸發下面的onSwooleShutDown事件
129      * @param $server
130      */
131     public function onSwooleStart($server)
132     {
133         $this->setProcessName('SwooleMaster');
134         $debug = debug_backtrace();
135         $this->pidFile = __DIR__ . "/temp/" . str_replace("/" , "_" , $debug[count($debug) - 1] ["file"] . ".pid" );
136         $pid = [$server->master_pid , $server->manager_pid];
137         file_put_contents($this->pidFile , implode(",", $pid));
138     }
139 
140     /**
141      * @param $server
142      * 已關閉全部Reactor線程、HeartbeatCheck線程、UdpRecv線程
143      * 已關閉全部Worker進程、Task進程、User進程
144      * 已close全部TCP/UDP/UnixSocket監聽端口
145      * 已關閉主Reactor
146      * @warning
147      * 強制kill進程不會回調onShutdown，如kill -9
148      * 須要使用kill -15來發送SIGTREM信號到主進程才能按照正常的流程終止
149      * 在命令行中使用Ctrl+C中斷程序會當即中止，底層不會回調onShutdown
150      */
151     public function onSwooleShutDown($server)
152     {
153         echo "shutdown\n";
154     }
155 
156     /**
157      * @warning 進程隔離
158      * 該函數具備進程隔離性 ,
159      * {$this} 對象從 swoole_server->start() 開始前設置的屬性所有繼承
160      * {$this} 對象在 onSwooleStart,onSwooleManagerStart中設置的對象屬於不一樣的進程中.
161      * 所以這裏的pidFile雖然在onSwooleStart中設置了，可是是不一樣的進程，因此找不到該值.
162      * @param \swoole_server $server
163      * @param int            $worker_id
164      */
165     public function onSwooleWorkerStart(swoole_server $server, int $worker_id)
166     {
167         if($this->isTaskProcess($server))
168         {
169             $this->setProcessName('SwooleTask');
170         }
171         else{
172             $this->setProcessName('SwooleWorker');
173         }
174         $debug = debug_backtrace();
175         $this->pidFile = __DIR__ . "/temp/" . str_replace("/" , "_" , $debug[count($debug) - 1] ["file"] . ".pid" );
176         file_put_contents($this->pidFile , ",{$worker_id}" , FILE_APPEND);
177     }
178 
179     public function onSwooleWorkerStop($server,$worker_id)
180     {
181         echo "#worker exited {$worker_id}\n";
182     }
183 
184     /**
185      * @warning 進程隔離 在task_worker進程內被調用
186      * worker進程可使用swoole_server_task函數向task_worker進程投遞新的任務
187      * $task_id和$src_worker_id組合起來纔是全局惟一的，不一樣的worker進程投遞的任務ID可能會有相同
188      * 函數執行時遇到致命錯誤退出，或者被外部進程強制kill，當前的任務會被丟棄，但不會影響其餘正在排隊的Task
189      * @param $server
190      * @param $task_id 是任務ID 由swoole擴展內自動生成，用於區分不一樣的任務
191      * @param $src_worker_id 來自於哪一個worker進程
192      * @param $data 是任務的內容
193      * @return mixed $data
194      */
195     public function onSwooleTask($server , $task_id, $src_worker_id,$data)
196     {
197         // todo
198     }
199 
200     public function onSwooleFinish()
201     {
202         // todo
203     }
204 
205     /**
206      * 當工做進程收到由 sendMessage 發送的管道消息時會觸發onPipeMessage事件。worker/task進程均可能會觸發onPipeMessage事件。
207      * @param $server
208      * @param $src_worker_id 消息來自哪一個Worker進程
209      * @param $message 消息內容，能夠是任意PHP類型
210      */
211     public function onSwoolePipeMessage($server , $src_worker_id,$message)
212     {
213         // todo
214     }
215 
216     /**
217      * worker進程發送錯誤的錯誤處理回調 .
218      * 記錄日誌等操做
219      * 此函數主要用於報警和監控，一旦發現Worker進程異常退出，那麼頗有多是遇到了致命錯誤或者進程CoreDump。經過記錄日誌或者發送報警的信息來提示開發者進行相應的處理。
220      * @param $server
221      * @param $worker_id 是異常進程的編號
222      * @param $worker_pid  是異常進程的ID
223      * @param $exit_code  退出的狀態碼，範圍是 1 ～255
224      * @param $signal 進程退出的信號
225      */
226     public function onSwooleWrokerError($server ,$worker_id,$worker_pid,$exit_code,$signal)
227     {
228         echo "#workerError:{$worker_id}\n";
229     }
230 
231     /**
232      *
233      */
234     public function onSwooleManagerStart()
235     {
236         $this->setProcessName('SwooleManager');
237     }
238 
239     /**
240      * @param $server
241      */
242     public function onSwooleManagerStop($server)
243     {
244         echo "#managerstop\n";
245     }
246 
247     /**
248      * 客戶端鏈接
249      * onConnect/onClose這2個回調發生在worker進程內，而不是主進程。
250      * UDP協議下只有onReceive事件，沒有onConnect/onClose事件
251      * @param $server
252      * @param $fd
253      * @param $reactorId
254      */
255     public function onSwooleConnect($server ,$fd ,$reactorId)
256     {
257         echo "#{$fd} has connected\n";
258         $server->send($fd , "please input your name\n");
259     }
260 
261     /**
262      * @param $server server對象
263      * @param $fd 文件描述符
264      * @param $reactorId reactor線程id
265      * @param $data 數據
266      */
267     public function onSwooleReceive($server,$fd,$reactorId, $data)
268     {
269         $data = json_decode($data, true);
270         $exist = $this->table->exist($fd);
271         $from    = $data ['from'];
272         $to      = $data ['to'];
273         $message = $data ['message'];
274 
275         if(!$exist) {
276             foreach ($this->table as $row)
277             {
278                 if($row ['name'] == $from)
279                 {
280                     $server->send($fd , 'name already exists');
281                     return ;
282                 }
283             }
284             $this->table->set($fd , ['name' => $from , 'fd' => $fd]);
285             $server->send($fd , "welcome to join tcp chat room\n");
286         }
287         // 發送給其餘人 .
288         if($to == 'all')
289         {
290             $this->sendToAllExceptHim($server , $message , $fd);
291             return ;
292         }
293         if(!empty($to) && !empty($message))
294         {
295             $this->sendToOne($server ,$message ,$to);
296         }
297         return ;
298     }
299 
300     private function sendToOne($server , $message , $name)
301     {
302         foreach ($this->table as $row)
303         {
304             if($row ['name'] == $name)
305             {
306                 $server->send($row ['fd'] , $message);
307                 return ;
308             }
309         }
310     }
311 
312     private function sendToAllExceptHim($server , $message, $fd)
313     {
314         foreach ($this->table as $row)
315         {
316             if($row['fd'] == $fd) continue ;
317             $server->send($row ['fd'] , $message);
318         }
319     }
320 
321     /**
322      * 鏈接斷開，廣播業務須要從redis | memcached | 內存 中刪除該fd
323      * @param $server
324      * @param $fd
325      * @param $reactorId
326      */
327     public function onSwooleClose($server, $fd ,$reactorId)
328     {
329         $this->table->del($fd);
330     }
331 
332     public function setProcessName($name)
333     {
334         if(function_exists('cli_set_process_title'))
335         {
336             @cli_set_process_title($name);
337         }
338         else{
339             @swoole_set_process_name($name);
340         }
341     }
342 
343     /**
344      * 返回真說明該進程是task進程
345      * @param $server
346      * @return bool
347      */
348     public function isTaskProcess($server)
349     {
350         return $server->taskworker === true ;
351     }
352 
353     /**
354      * main 運行入口方法
355      */
356     public static function main()
357     {
358         self::$_worker->start();
359     }
360 }
361 
362 $config = ['server' => ['worker_num' => 4 , "task_worker_num" => "20" , "dispatch_mode" => 3 ] , 'host' => '0.0.0.0' , 'port' => 9501];
363 $server = new Server($config);
364 Server::main() ;