java中创建多线程的方式

在java中比较常用的有三种创建多线程的方式。

方式一：继承Thread类，要重写run方法。

在MyThread类

 public class MyThread extends Thread {
     @Override
     public void run() {
         for (int i = 0; i < 100    ; i++) {
　　　　　　　　　　//获取线程名称
             System.out.println(getName()+":"+i);
         }
         super.run();
     }
 }

测试类：

 public class MyThreadDemo {
     public static void main(String[] args) {
         MyThread my1 = new MyThread();
         MyThread my2 = new MyThread();
         my1.setName("张飞");
         my2.setName("关羽");

         my1.setDaemon(true);
         //开启线程
         my1.start();
         my2.start();
         //设置主线程名称
         Thread.currentThread().setName("刘备");

         for (int i = 0; i < 5; i++) {
             System.out.println(Thread.currentThread().getName()+":"+i);
         }
     }
 }

常用方法：

public final void setDaemon(boolean on):将该线程标记为守护线程或用户线程。

当正在运行的线程都是守护线程时，Java 虚拟机退出。 该方法必须在启动线程前调用

public static void sleep(long millis,int nanos) 在指定的毫秒数内让当前正在执行的线程休眠

public static void yield():暂停当前正在执行的线程对象，并执行其他线程。让多个线程的执行更和谐，但是不能靠它保证一人一次。

public final void join():等待该线程终止。 该线程终止才能执行其他线程

优先级

public final int getPriority():返回线程对象的优先级

public final void setPriority(int newPriority)：更改线程的优先级

 线程默认优先级是5。

 程优先级的范围是：1-10。

 线程优先级高仅仅表示线程获取的 CPU时间片的几率高，但是要在次数比较多，或者多次运行的时候才能看到比较好的效果。

这里再提一句：start和run方法有什么区别：run方法就是执行括号里的代码  start方法是首先启动了线程，然后由jvm调用run方法。

方式二：

实现Runnable接口，也要重写run方法。创建Thread对象，将Runnable作为参数传递。

 //测试Runnable
     public static void testRunnable(){
         //创建Runnable对象
         Runnable r = new Runnable() {

             @Override//run()方法没有返回值,只能通过try抛出异常
             public void run() {
                 System.out.println("当前线程的名字是:"+Thread.currentThread().getName());
                 try {
                     Thread.sleep(2000);
                 } catch (InterruptedException e) {
                     // TODO: handle exception
                 }
             }
         };
         //Thread包装Runnable
         Thread t = new Thread(r);
         t.start();
     }

方式三：

实现Callable接口。在展示Demo之前，说一说实现这个接口需要用到的类和接口。

ExecutorService（线程池）：接口，它的超级接口是Executor。

下面这些是返回ExecutorService对象的方法。

* public static ExecutorService newCachedThreadPool()   创建corePoolSize为0，最大线程数为整型的最大数，线程   keepAliveTime为1分钟，缓存任务的队列为SynchronousQueue的线程池。

* public static ExecutorService newFixedThreadPool(int nThread)   创建固定大小的线程池

* public static ExecutorService newSingleThreadExecutor()    创建大小为1的固定线程池

可以执行Runnable对象或者Callable对象代表的线程。

　Future<?> submit(Runnable task)

<T> Future<T> submit(Callable<T> task)

Executors(类):提供了用于此包中所提供的执行程序服务的工厂方法。也就是说可以用它来创建线程池。

Future(接口)，API解释：

Future 表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并获取计算的结果。计算完成后只能使用 get 方法来获取结果，如有必要，计算完成前可以阻塞此方法。取消则由 cancel 方法来执行。还提供了其他方法，以确定任务是正常完成还是被取消了。一旦计算完成，就不能再取消计算。如果为了可取消性而使用 Future 但又不提供可用的结果，则可以声明 Future<?> 形式类型、并返回 null 作为底层任务的结果。说白了就是获取Callable返回值的对象。

FutureTask(类):它实现的接口：Runnable Future<V> RunnableFuture<V>。

构造方法：

FutureTask(Callable<V> callable)

创建一个 FutureTask，一旦运行就执行给定的 Callable。

FutureTask(Runnable runnable, V result)

创建一个 FutureTask，一旦运行就执行给定的 Runnable，并安排成功完成时 get 返回给定的结果 。

 //测试Callable,可以通过throws抛出异常
     public static void testCallable() throws InterruptedException, ExecutionException{
         //创建对象
         Callable<Student> c = new Callable<Test.Student>() {

             @Override
             //call()方法可以有返回值,并且可以通过throws抛出异常
             public Student call() throws Exception {
                 System.out.println("当前线程的名称是:"+Thread.currentThread().getName());
                 Thread.sleep(2000);
                 return new Student("张飞", 30);
             }
         };
         //包装对象  第一种方法
         FutureTask<Student> ft = new FutureTask<Student>(c);

         try {
             //执行线程
             new Thread(ft).start();
             //获取结果
             System.out.println(ft.get().getName()+ft.get().getAge());
         } catch (Exception e) {
             e.printStackTrace();
         }

         //第二种方法
         //创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程。
         ExecutorService es =  Executors.newSingleThreadExecutor();
         //Executors  Executor  ExecutorService
         Future<Student> f = es.submit(new Callable<Student>() {

             @Override
             public Student call() throws Exception {

                 return new Student("关羽", 33);
             }
         });
         System.out.println(f.get().getName() + f.get().getAge());

     }