java中多線程的一些總結以及demo – JAVA編程語言程序開發技術文章

  1、線程可以驅動任務。任務由實現Runnable接口的類定義。New Thread(Runnable)這段代碼就是前面一句話最好的詮釋。任何線程都可以啟動另外一個線程。
由於所有其他線程都是由Main線程所產生的,所以main線程的優先級相對較高。要區分出任務和線程是不同的概念,是以線程去驅動任務的。
 
package com.thread.demo;
 
public class Threademo {
 
    /**
    * @param args
    */
    public static void main(String[] args) {
       Thread thread=new Thread(new Thread1());
       thread.start();
       System.out.println("sdfsdfsdf");
    }
}
class Thread1 implements Runnable{
    private final int i=0;
    private static int count=10;
    public void status(){
       System.out.println("the id is: "+count);
    }
    @Override
    public void run() {
       while(count–!=0){
           status();
           try {
              Thread.sleep(1000);
           } catch (InterruptedException e) {
              // TODO Auto-generated catch block
              e.printStackTrace();
           }
       }
     
    }
  
}
 
 
 
 
 
2、關於ExecutorService線程管理器的使用:
package com.thread.demo;
 
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 
public class Executordemo {
 
  
    public static void main(String[] a) throws InterruptedException{
       //ExecutorService為每個任務創建合適的上下文,也就是驅動任務的線程。
        ExecutorService service=Executors.newCachedThreadPool();
       for(int i=0;i<6;i++){
           service.execute(new Thread2());
           Thread.sleep(1000);
       }
        service.shutdown();
    }
}
class Thread2 implements Runnable{
    
    private final int i=0;
    //共同對同一個資源進行競爭
    private static int count=10;
    public void status(){
       System.out.println("the id is: "+count);
    }
    @Override
    public void run() {
       while(count–>0){
           status();
           try {
              Thread.sleep(1000);
           } catch (InterruptedException e) {
              // TODO Auto-generated catch block
              e.printStackTrace();
           }
       }
     
    }
  
}
 
理解存在於代碼的註釋當中。
 
3、這段代碼與前面一段代碼的區別是:這段代碼預先為即將執行的任務分配瞭5個線程,當任務提交到線程中時就不用再去重新分配線程瞭。減少瞭分配線程時的開銷。
 
public class Executordemo2 {
 
    /**
    * @param args
    */
    public static void main(String[] args) {
       ExecutorService executor=Executors.newFixedThreadPool(5);
       for(int i=0;i<5;i++){
           executor.execute(new Thread3());
       }
       executor.shutdown();
 
    }
 
}
 
 
4、線程管理器隻分配瞭1個線程的情況,導致所有的任務隻有根據自己提交的順序進行執行,代碼如下:
package com.thread.demo;
 
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 
public class SingleThreadDemo {
 
    /**
    * @param args
    */
    public static void main(String[] args) {
       ExecutorService excutor=Executors.newFixedThreadPool(1);
       for(int i=0;i<5;i++){
           excutor.execute(new Single());
           try {
              Thread.sleep(1000);
           } catch (InterruptedException e) {
              // TODO Auto-generated catch block
              e.printStackTrace();
           }
        }
         
       excutor.shutdown();
    }
}
class Single implements Runnable{
   private static int i=0;
    @Override
    public void run() {
       i++;
       System.out.println("sdfsdf"+i);
    }
  
}
 
5、Java中的futrue設計模式:
在java中,如果需要設定代碼執行的最長時間,即超時,可以用java線程池ExecutorService類配合Future接口來實現。Future接口是JAVA標準API的一部分,在java。Util。concurrent包中。Future接口是java線程Future模式的實現,可以來進行異步計算。
 
Futrue模式可以這樣描述:我有一個任務,提交瞭Future,future替我完成這個任務,期間我可以幹別的任何事。
 
 
6、關於futrue以及java中的Callable接口的使用,代碼如下:
package com.thread.demo;
 
import java.util.ArrayList;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
 
public class FutrueCllasbledemo {
 
    /**
    * @param args
    * @throws ExecutionException
     * @throws InterruptedException
     */
    public static void main(String[] args) throws InterruptedException, ExecutionException {
       ExecutorService service=Executors.newCachedThreadPool();
       ArrayList<Future<String>> arraylist=new ArrayList<Future<String>>();
       for(int i=0;i<5;i++){
            arraylist.add(service.submit(new Callback()));
        }
        for(Future<String> future:arraylist){
        System.out.println(future.get());
        }
      
        service.shutdown();
    }
 
}
 
 
class Callback implements Callable<String>{
 
    @Override
    public String call() throws Exception {
       // TODO Auto-generated method stub
       return "hello";
    }
 
}
 
 
 
7、關於對線程使用sleep演示,由於當前線程掛起,自然導致線程驅動的任務掛起。以下為演示例子:
 
package com.thread.demo;
 
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 
public class ThreadCompeteDemo {
   public static void main(String[] a){
       ExecutorService service=Executors.newCachedThreadPool();
       service.execute(new Threademo4());
       service.execute(new Threademo5());
     
       service.shutdown();
   }
}
 
class Threademo4 implements Runnable{
 
    @Override
    public void run() {
       try {
           Thread.sleep(1000);
       } catch (InterruptedException e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
       }
       System.out.println("liu");
     
    }
  
}
class Threademo5 implements Runnable{
 
    @Override
    public void run() {
       System.out.println("yangyang");
    }
  
}
 
 關於一些重要特性的總結:
線程的優先級將該線程的重要性傳遞給瞭調度器。
Excutor線程管理器可以對管理器的線程實行一次性的全部關閉。
創建任務,將線程附著到任務上,以使線程可以驅動任務。
在java中,Thread類並不執行任何操作,它隻是驅動他的任務。
Java的線程機制基於來自c的低級的p線程方式。
ThreadFactory工廠通常和ExecutorService 聯合使用,通常前者位於後者的構造函數中,ThreadFactory主要為ExecutorService線程管理器產生的線程定制某些行為和屬性。

作者“690360459-qq-com”
 

發佈留言