Scala語法(五) Actor與線程池

前言

在前面的章節內, 我們介紹了Scala基礎、集合、方法與函數體, 以及模式匹配的相關知識. 本章簡單的介紹了Actor的相關知識.

---

正文

• 創建Actor
  個人理解Actor對象與Java內的Thread對象相似. 創建時通過繼承的方式創建Actor類, 並通過start()方法啓動Actor子線程.

import scala.actors.Actor


/**
 * 使用Actor的方式啓動線程.
 * 1. 調用start()方法啓動Actor
 * 2. 調用start()方法後, act方法會被執行
 * 3. 向Actor發送消息.
 * 
 * | 發送異步消息 沒有返回值
 * |? 發送同步消息,等待返回值
 * |! 發送異步消息,返回值爲Future[Any]
 * */
// Actor已經2.11.x版本已經被移除了 使用的是Akka內的Actor.
object QuickActorA extends  Actor{
  def act(){
    for( i <- 1 to 100){
      println("actor1-"+i)
      Thread.sleep(1000)
    }
  }
}
object QuickActorB extends  Actor{
  def act(){
    for( i <- 1 to 100){
      println("actor2-"+i)
      Thread.sleep(1000)
    }
  }
}
object QucikActor {
    def main(args: Array[String]): Unit = {
      QuickActorA.start()
      QuickActorB.start()
    }
}

• 持久通信

import scala.actors.Actor

/**
 * Actor不斷的接收消息.
 * 
 * */
class QuickActorReceiveA extends Actor {
  def act():Unit = {
    while(true){
      receive{
        case "start" => {
          println("Start")
        }
        case "stop" => {
          println("Stop")
        }
      }
    }
  }
}
object QuickActorReceive {
  def main(args: Array[String]): Unit = {
    val actor = new QuickActorReceiveA()
    actor.start()
    actor ! "start"
    actor ! "stop"
  }
}

• React方法通信

import scala.actors.Actor

class QuickActorReactA extends Actor {
  def act():Unit ={
    loop{
      // 複用線程池
      react{
        case "start" => {println("start"); Thread.sleep(1000); }
        case "stop" => {println("stop") ;Thread.sleep(1000);}
        case "exit" => {exit()}
      }
    }
  }
}
object QuickActorReact {
  def main(args: Array[String]): Unit = {
      val quickActorReactA = new QuickActorReactA()
      quickActorReactA.start()
      quickActorReactA ! "start"
      quickActorReactA ! "stop"
      quickActorReactA ! "exit"

  }
}

• 創建線程池(Java)

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;


/***
 * Java內進行線程池聲明代碼.
 */
public class QuickJavaThreadPool {
	public static void main(String[] args) {
		// 定義線程池 並向其中塞任務
		ExecutorService pool = Executors.newCachedThreadPool();
		for(int i=0;i<10;i++) {
			pool.execute(new Runnable() {
				
				@Override
				public void run() {
					System.out.println("Thread Name:"+Thread.currentThread().getName());
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			});
		}
		
		Future<Integer> future = pool.submit(new Callable<Integer>() {

			@Override
			public Integer call() throws Exception {
				return 1;
			}
			
		});
		
//		pool.shutdown();
	}
}

• 創建線程池(Scala)

import java.util.concurrent.Executors
import java.util.concurrent.Future
import java.util.concurrent.Callable

/**
 * 在Scala內使用線程池技術 創建 線程池.
 *
 */
object QuickThreadPool {
  def main(args: Array[String]): Unit = {
    val pool = Executors.newCachedThreadPool()
    for (i <- 1 to 10) {
      pool.execute(new Runnable() {
        def run(): Unit = {
          println("Thread-Name:" + Thread.currentThread().getName())
          Thread.sleep(1000)
        }
      })
    }

    
    val future:Future[Int] = pool.submit(new Callable[Int](){
      override def call():Int ={
        Thread.sleep(1000)
        100
      }
    }) 
    var status = future.isDone()
    Thread.sleep(1000)
    status = future.isDone()
    if(status){
      println(future.get())
    }
//    pool.shutdown()
  }
}