java创建线程的方式

java创建线程的三种方式

1、继承Thread类创建线程类

• 定义Thread类的子类，并重写该类的run方法，该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。
• 创建Thread子类的实例，即创建了线程对象。
• 调用线程对象的start()方法来启动该线程。

2、通过Runnable接口创建线程类

• 定义runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
• 创建 Runnable实现类的实例，并依此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
• 调用线程对象的start()方法来启动该线程。

3、通过Callable和Future创建线程

• 创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。
• 创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。
• 使用FutureTask对象作为Thread对象的target创建并启动新线程。
• 调用FutureTask对象的get()方法来获得子线程执行结束后的返回值

1. 写一个类继承Thread重写run方法。run方法中写该线程的业务逻辑

示例代码：

/**
 * 线程的创建一：extends Thread   并重写run()方法
 * main方法也是一个线程
 * 想要我们的线程与main线程并发执行必须在main方法要执行的业务逻辑之前启动我们自定义的线程
 */
public class Demo01 {
    public static void main(String[] args) {
        Thread1 thread1 = new Thread1();
        thread1.start(); // 启动thread1线程
        Thread2 thread2 = new Thread2();
        thread2.start(); // 启动thread2线程

        /**
         * main方法业务逻辑
         * 控制台打印3000-40000
         */
        for (int i = 3000; i < 40000; i++) {
            System.out.println(Thread.currentThread().getName() + "---->" + i);
        }
    }
}

/**
 * 线程演示 控制台输出1-999
 */
class Thread1 extends Thread {
    @Override
    public void run() {
        for (int i = 1; i < 1000; i++) {
            System.out.println(this.getName() + "====>" + i);
        }
    }
}

/**
 * 线程演示 控制台输出2000-2999
 */
class Thread2 extends Thread {
    @Override
    public void run() {
        for (int i = 2000; i < 3000; i++) {
            System.out.println(Thread.currentThread().getName() + "####>" + i);
        }
    }
}

运行结果：只截取了能观察出并发执行的部分。

2.写一个类implements Runnable 并重写run()方法，run()方法是线程的业务逻辑。

示例代码：

/**
 * 线程的创建方法二： implements Runnable 并重写run()方法
 * 演示thread与main线程并发
 */
public class Demo02 {
    public static void main(String[] args) {
        Thread thread = new Thread(new Thread3(), "线程一");
        thread.start();
        /**
         * main方法业务逻辑
         * 控制台打印2000-29999
         */
        for (int i = 2000; i < 30000; i++) {
            System.out.println(Thread.currentThread().getName() + "****>" + i);
        }
    }
}

/**
 * 线程演示控制台输出0-999
 */
class Thread3 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println(Thread.currentThread().getName() + "---->" + i);
        }
    }
}

运行结果：只截取了能观察出并发执行的部分。

3.写一个类implements  Callable<V>并重写call()方法，call()方法是线程的业务逻辑。该方法有返回值V。

示例代码：

public class Demo03 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<Integer> futureTask1=new FutureTask<Integer>(new Thread4());
        FutureTask<BigInteger>futureTask2=new FutureTask<BigInteger>(new Thread5());
        new Thread(futureTask1,"求和").start();
        new Thread(futureTask2,"求和").start();

        System.out.println("------------------------------------------------");
        Integer integer =futureTask1.get();// 调用get方法获取线程的返回值 会阻塞线程执行完毕后才返回值

        BigInteger bigInteger = futureTask2.get();
        System.out.println("1+2+3+...+100的和是："+integer);
        System.out.println("1*2*3*...*100的积是：" + bigInteger);
    }
}

class Thread4 implements Callable<Integer> {
    /**
     * 该线程实现 1+2+3+..+100
     *
     * @return
     * @throws Exception
     */
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i <= 100; i++) {
            sum += i;
            System.out.println(Thread.currentThread().getName()+"---->"+sum);
            Thread.sleep(300);
        }
        return sum;
    }
}

class Thread5 implements Callable<BigInteger> {
    /**
     * 该线程实现 1*2*3*...*100
     *
     * @return
     * @throws Exception
     */
    @Override
    public BigInteger call() throws Exception {
        BigInteger bigInteger = BigInteger.ONE;
        for (long i = 1; i <= 100; i++) {
            bigInteger = bigInteger.multiply(BigInteger.valueOf(i));
            System.out.println(Thread.currentThread().getName() + "****>" + bigInteger);
            Thread.sleep(300);
        }
        return bigInteger;
    }
}

注意：一般常用实现Runnable接口来写一个线程。

因为java不支持多继承，如果一个类已经继承了其他类则不能在继承Thread来写一个线程类实现接口更具有通用性。

一、并行和并发有什么区别

1. 并行是指两个或多个时间在同一时刻发生（同时进行），并发是指两个或多个事件在同一时间间隔发生（交替进行）。
2. 并行是在不同实体上的多个事件，并发是在同一实体上的多个时间。
3. 并发在一台处理器上“同时”处理多个任务，并行在多台处理器上同时处理多个任务。如hadoop分布式集群。

二、线程和进程的区别

      进程是程序运行和资源分配的基本单位，一个程序至少好有一个进程，一个进程至少有一个线程。进程在执行过程中拥有独立的内存单元，而多个线程共享内存资源。线程是进程的一个实体，是CPU调度和分派的基本单位，是比程序更小能独立运行的基本单位。同一进程中的多个线程之间可以并发执行。

三、线程有哪些状态

线程通常有五种状态，新建，就绪，运行，阻塞和死亡。

1. 新建状态：在生成线程对象，并没有调用该对象的start方法，这是线程的新建状态。
2. 就绪状态：当线程调用了线程对象的start方法后，该线程就进入了就绪状态，等待CPU调度并没有运行。在线程运行之后，从等待或睡眠中回来之后，也会处于就绪状态。
3. 运行状态：线程调度程序将处于就绪状态的线程设置为当前线程（获得CPU资源），此时县城就进入了运行状态，开始运行run方法中的代码。
4. 阻塞状态：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：

• 等待阻塞 -- 通过调用线程的wait()方法，让线程等待某工作的完成。
• 同步阻塞 -- 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态。
• 其他阻塞 -- 通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

  5.死亡状态：如果一个线程的run方法执行结束或者调用了stop方法后，该线程就会死亡，对于死亡的线程无法在使用start方法使其进入就绪状态。

线程的状态转换图：

四、线程的run()和start()有什么区别？

      每个线程都是通过某个特定的Thread对象所对应的run()方法来完成其操作的，run()方法称为线程体，通过调用Thread类的start()方法启动一个线程。

      start()方法用来启动一个线程，真正实现了多线程运行。这时无需等待run()方法体代码体执行完毕，可以直接继续执行下面的代码；这时线程是处于就绪状态的，并没有运行。然后通过Thread类调用run()方法来完成其运行状态，它包含了要执行这个线程的内容，run()方法运行结束，此线程终止。

      run()方法是在本线程里的，只是线程里的一个方法，而不是多线程的。如果直接调用run()方法，相当于是调用了一个普通方法而已，直接调用run()方法必须等待run()方法执行完毕才执行下面的代码。程序依顺序执行。所以多线程执行时要是用start()方法而不是run()方法。

五、Runnable和Callable的区别？

      Runnable接口中的run()方法的返回值是void，它做的事情只是纯粹地去执行run()方法中的代码。

      Callable接口中的call()方法是有返回值的，是一个泛型，和Future、FutureTask配合可以用来获取异步执行的结果。