Java创建线程的多种方式

- 通过extends Thread；
- 通过implements Runnable；
- 通过匿名内部类中实现；
- 通过实现Callable接口实现。

1、通过extends Thread

  public class ThreadDemo1 extends Thread {

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(i + ":" + Thread.currentThread().getName());
        }
    }

    public static void main(String[] args) {
        // 实例化线程
        Thread thread = new ThreadDemo1();
        // 启动线程
        thread.start();
    }

}  

2、通过implements Runnable

public class ThreadDemo2 implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(i + ":" + Thread.currentThread().getName());
        }
    }

    public static void main(String[] args) {
        Runnable runnable = new ThreadDemo2();
        // 实例化线程并传入线程体
        Thread thread = new Thread(runnable);
        // 启动线程
        thread.start();
    }
}

3、通过匿名内部类中实现

public class ThreadDemo3 {

    /**
     * 内部类中使用Thread创建
     */
    public void test(){
        Thread thread = new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(i + ":" + Thread.currentThread().getName());
                }
            }
        };
        // 启动线程
        thread.start();
    }

    public static void main(String[] args) {
        ThreadDemo3 threadDemo3 = new ThreadDemo3();
        threadDemo3.test();
        threadDemo3.test2();
    }

    /**
     * 内部类中使用Runnable创建
     */
    public void test2(){
        // 匿名类方式创建线程
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(i + ":" + Thread.currentThread().getName());
                }
            }
        };
        Thread thread = new Thread(runnable);
        thread.start();
    }
}

4、通过实现Callable接口实现。

public class CallableDemo implements Callable<Object> {
    private String name;
    public CallableDemo(String name){
        this.name = name;
    }

    @Override
    public Object call() throws Exception {
        for (int i = 0; i < 10; i++) {
            System.out.println(i + ":" + Thread.currentThread().getName() + ":" + name);
        }
        return "true";
    }

    public static void main(String[] args) throws Exception {
        CallableDemo callableDemo1 = new CallableDemo("one");
        CallableDemo callableDemo2 = new CallableDemo("two");
        CallableDemo callableDemo3 = new CallableDemo("three");
        // 创建线程池执行任务
        ExecutorService ser = Executors.newFixedThreadPool(3);
        // 提交执行
        Future<Object> future1 = ser.submit(callableDemo1);
        Future<Object> future2 = ser.submit(callableDemo2);
        Future<Object> future3 = ser.submit(callableDemo3);
        // 获取结果
        Object result = future1.get();
        System.out.println(result);
        // 关闭服务
        ser.shutdown();
    }

}

线程的一些方法

public class ThreadDemo1 implements Runnable{

    @Override
    public void run() {
        System.out.println("线程的id：" + Thread.currentThread().getId());
        System.out.println("线程的名称：" + Thread.currentThread().getName());
        System.out.println("线程的优先级：" + Thread.currentThread().getPriority());
        System.out.println("线程的状态：" + Thread.currentThread().getState());
        System.out.println("线程是否处于活动状态：" + Thread.currentThread().isAlive());
        System.out.println("是否是守护线程：" + Thread.currentThread().isDaemon());
        System.out.println("线程是否中断：" + Thread.currentThread().isInterrupted());
    }

    public static void main(String[] args) {
        Runnable runnable = new ThreadDemo1();
        // 实例化线程并传入线程体
        Thread thread = new Thread(runnable);
        // 启动线程
        thread.start();
    }
}

线程的优先级

线程的切换是由线程调度控制的。无法通过代码控制，可以通过提高线程的优先级来最大程度的改善线程获取时间片段的几率。

线程优先级高并不一定会最先执行

线程的优先级分为10级： 1 - 10 级，1级最低，10级最高。

线程有三个常量来表示最低、最高和默认的优先级。

System.out.println(Thread.MAX_PRIORITY);        // 10 -- 最高优先级
System.out.println(Thread.MIN_PRIORITY);        // 1  -- 最低优先级
System.out.println(Thread.NORM_PRIORITY);       // 5  -- 默认优先级

Thread.currentThread().setPriority(10);         // 设置线程优先级

守护线程

Thread.currentThread().setDaemon(true);         // 设置守护线程

设置守护线程需要在 start() 方法之前设置

守护线程的特点：

当线程只剩下守护线程时，所有的守护线程强制终止。

如： gc 就是运行在一个守护线程上的。

sleep() -- 休眠

Thread.sleep(1000);                             // 线程休眠 单位：ms

该方法会使当前线程进入阻塞状态指定的ms，当阻塞时间到时间后，当前线程会重新进入Runnable状态，等待分配时间片。

yield() -- 让出当前时间片

Thread.yield();

该方法会使当前线程让出当次CPU时间片回到Runnable的状态，等待分配时间片。

join()

Thread.currentThread().join();

该方法用户等待当前线程结束。

synchronized -- 同步锁

synchronized (this){
            
}

其他的方法 -- Object的 wait() 和 notify()

Thread.currentThread().wait();
Thread.currentThread().notify();

wait()方法的等待机制需要和锁机制配合使用。