java中多线程的一些总结以及demo

  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线程管理器产生的线程定制某些行为和属性。