java语言三种方法创建线程

1.thread方法

1.首先创建一个类继承Thread，并重写Thread类中的run方法。继承后重新写方法run，run方法就是线程要执行的任务方法。

2.new一个Thread对象，通过对象调用start方法，执行创建的线程。

package com.kkb.task4_5;

public class TestThread {
    public static void main(String[] args) {
        Thread thread =new MyThread();
        thread.start();
        for (int i=0;i<5;i++){
            System.out.println("主方法main方法被执行----");
            System.out.println(Thread.currentThread().getName()+"<->"+i);
        }

    }
    static class MyThread extends Thread{
        @Override
        public void run() {//继承后重新写方法run，run方法就是线程要执行的任务方法
            /**
             * 这里的代码就是一条新的执行路径
             * 这个执行路径的触发方式不是run方法，而是通过Thread对象的调用start方法
             */
            System.out.println("run方法里面的任务被执行----");
            for (int i=0;i<5;i++){
                System.out.println(Thread.currentThread().getName()+"<->"+i);//线程被执行
            }
        }
    }
}

3。这里我们看到main方法和run方法里面的都有一个要执行的循环语句，这时运行程序，两个线程并发（指两个或者多个事件在同一时间段发生）运行，java采用的是抢占调度，输出结果就是这个语句抢到了cpu就优先输出。这就引出一个问题如何实现线程的排队执行？请参考下篇文章

抢占式调度：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，

4.执行结果如下。并且每次运行，输出结果顺序大概率都会变化。

2.Runnable方法

1.首先创建一个类继承Runnnable，并重写Runnnable类中的run方法。

2.new一个任务Runnnable对象。

3.new一个Thread对象，将任务Runnnable对象赋值给Thread。

4.通过Thread对象调用start方法，执行创建的线程。

package com.kkb.task4_5;

public class
TestRunnable {
    public static void main(String[] args) {
        Runnable runnable =new MyRunnable();
        Thread thread = new Thread(runnable);
        thread.start();
        for (int i=0;i<3;i++){
            System.out.println(Thread.currentThread().getName()+"<-->"+i);//main方法

        }

    }
    static class MyRunnable implements Runnable{

        @Override
        public void run() {
            for (int i=0;i<3;i++){
                System.out.println(Thread.currentThread().getName()+"<-->"+i);//线程1

            }
        }
    }
}

5.执行结果如下。并且每次运行，输出结果顺序大概率都会变化。

实现Runnable和继承Thread相比有如下优势：

• 通过创建任务，然后分配给线程的方式实现的多线程，更适合多个线程同时执行相同任务的情况。

• 可以避免单继承所带来的局限性，因为通过实现接口，可以多实现，多层继承。

• 任务和线程本身是分离的，提高了程序的健壮性。

• 后续的线程池技术，接受Runnable类的任务，不接受Thread类型的线程。

3Callable方法

Callable使用步骤

1. 编写类实现Callable接口 , 实现call方法

class XXX implements Callable<T> {

        @Override

        public <T> call() throws Exception {

                  return T;

       }

}

2. 创建FutureTask对象 , 并传入第一步编写的Callable类对象

      FutureTask<T> future = new FutureTask<>(callable);

3. 通过Thread,启动线程 new Thread(future).start();

package com.kkb.task4_5;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class TestCallable {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<Integer> callable = new MyCallable();//多态
        FutureTask<Integer>  task= new FutureTask<>(callable);
        new Thread(task).start();
        Integer j = task.get();
        for (int i=0;i<5;i++){
            try {
                Thread.sleep(1000);//循环过程中加入休眠时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(i);
        }
    }
    static class MyCallable implements Callable<Integer>{


        @Override
        public Integer call() throws Exception {
            Thread.sleep(1000);
            for (int i=0;i<5;i++){
                System.out.println(i);
            }
            return 100;
        }
    }
}

4.执行结果如下,且输出结果唯一，为什么会唯一，下面解释。

解释：Callable获取返回值 Callalble接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执 行，如果不调用不会阻塞。

在上面代码处我们使用了    Integer j = task.get();意思是没获取到 Callalble继承类线程执行任务的返回值时，主进程下面代码不会执行。如果将此行代码删除，则输出结果变得无序。

Callable获取返回值

Callalble接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执 行，如果不调用不会阻塞。

Runnable 与 Callable的相同点

• 都是接口 都可以编写多线程程序 都采用Thread.start()启动线程

Runnable 与 Callable的不同点

• Runnable没有返回值；

• Callable可以返回执行结果 Callable接口的call()允许抛出异常；

• Runnable的run()不能抛出

实现线程的同步（排队）执行：线程安全问题