Java基础---创建线程的几种方式

1.继承Thread类

        优点：代码简单

        缺点：该类无法继承别的类

public class DemoThread {
    public static void main(String[] args) {
        Ticket t1 = new Ticket();
        t1.setName("线程1");
        t1.start();

        Ticket t2 = new Ticket();
        t2.setName("线程2");
        t2.start();
    }
}
class Ticket extends Thread {

    @Override
    public void run() {
        for (int i = 1; i <= 10; i++) {
            System.out.println(Thread.currentThread().getName() + "卖出了第" + i + "号票");
        }
    }

}

2.实现Runnable接口

        优点：可以继承其他类，统一实现该接口的实例可以共享资源

        缺点：代码复杂

package com.shiyucj.a.thread;

/**
 * @Author: KKQ
 * @CreateTime: 2021/8/26 14:33
 * @Description:
 **/
public class DemoRunnable {
    public static void main(String[] args) {
        Ticket2 ticket = new Ticket2();
        new Thread(ticket, "线程1").start();
        new Thread(ticket, "线程2").start();
    }
}

class Ticket2 implements Runnable {

    @Override
    public void run() {
        for (int i = 1; i <= 10; i++) {
            System.out.println(Thread.currentThread().getName() + "卖出了第" + i + "号票");
        }
    }

}

3.实现Callable接口

        优点：可以继承其他类，统一实现该接口的实例可以共享资源        有返回值

        缺点：代码复杂

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


public class DemoCallable {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创造callable实现类的对象
        Callable<Object> oneCallable = new Ticket3<>();
        //使用FutureTask类包装Callable对象
        FutureTask<Object> oneTask = new FutureTask<>(oneCallable);

        Thread thread = new Thread(oneTask,"线程1");

        thread.start();

        //获取线程执行完毕的结果
        System.out.println(oneTask.get());
    }
}

class Ticket3<String> implements Callable {

    @Override
    public Object call() throws Exception {
        for (int i = 1; i <= 10; i++) {
            System.out.println(i);
        }
        return Thread.currentThread().getName()+"线程执行完毕";
    }
}

4.线程池方式

        优点：实现自动化装配，易于管理，循环利用资源

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Demo4 {
    public static void main(String[] args) {
        //创建一个指定线程的线程池
        ExecutorService pool= Executors.newFixedThreadPool(2);

        //将线程放到池子里并且执行
        pool.submit(new Ticket4());
        pool.submit(new Ticket4());

        pool.shutdown();
    }
}

class Ticket4 implements Runnable {

    @Override
    public void run() {
        for (int i = 1; i <= 10; i++) {
            System.out.println(Thread.currentThread().getName() + "卖出了第" + i + "号票");
        }
    }

}