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());
        
        

    }