java创建线程的三种方式

想写的基础性文章已达90篇文章了，无论是基础性技术文章还是生活所感到这篇就结束了，感谢一路陪伴的读者和朋友，感谢过去的自己，你陪我成长，我陪你长大。

以后会慢慢继续分享自己喜欢写的技术性文章，今后也就是慢慢分享java中级技术性文章的内容了，包括这篇关于创建线程的两种方式。

好了，我们还是按照以往的风格先看下线程的概念吧，先做一下理论性基础的铺垫。

先看下，百度百科对线程的介绍吧。线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。在Unix System V 及SunOS中也被称为轻量进程(lightweight processes)，但轻量进程更多指内核线程(kernel thread)，而把用户线程(user thread)称为线程。

同一进程中的多条线程将共享该进程中的全部系统资源，如虚拟地址空间，文件描述符和信号处理等等。但同一进程中的多个线程有各自的调用栈(call stack)，自己的寄存器(register context),自己的线程本地存储(thread-local storage)。一个进程可以有很多线程，每条线程并行执行不同的任务。

上面的内容，自己选了重要且易于理解的文字进行描述，看完可以理解就行了，下面我们先看下创建线程的第一种方式，继承Thread类实现里面的run()方法。

package com.wpw.threadconcurrent;


/**
 * @author pc
 */
public class TestThread extends Thread {
    @Override
    public void run() {
        System.out.println("当前线程的名称:" + Thread.currentThread().getName());
        /***
         * 默认优先级为5，可自定义设置
         * 优先级越小先执行
         */
        System.out.println("当前线程的优先级:" + Thread.currentThread().getPriority());
        System.out.println("当前线程的id:" + Thread.currentThread().getId());
        System.out.println("当前线程的运行状态:"+Thread.currentThread().getState().name());
    }


    public static void main(String[] args) {
        TestThread testThread = new TestThread();
        testThread.setPriority(3);
        testThread.setName("自定义线程名称");
        testThread.start();
    }
}

线程的第二种实现方式是实现Runnable接口实现里面的run()方法。

package com.wpw.threadconcurrent;


/**
 * @author pc
 */
public class RunnableTest {
    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("当前线程的名称:" + Thread.currentThread().getName());
                System.out.println("当前线程的优先级:" + Thread.currentThread().getPriority());
                System.out.println("当前线程的运行状态:" + Thread.currentThread().getState().name());
            }
        });
        thread.setName("Runnable接口");
        thread.setPriority(5);
        thread.start();
    }
}

自定义类实现Callable接口，进行异步任务的提交。

package com.wpw.threadconcurrent;


import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
import lombok.extern.slf4j.Slf4j;


import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;


@AllArgsConstructor
@NoArgsConstructor
@Data
@Slf4j
@Builder
@Accessors(chain = true)
public class MyCallable implements Callable<String> {


    private AtomicInteger flag = new AtomicInteger(0);
    private static final Integer FLAG = 0;


    @Override
    public String call() throws Exception {
        if (this.flag.get() == FLAG) {
            return "0";
        }
        if (this.flag.get() == 1) {
            try {
                while (true) {
                    System.out.println("flag=2");
                    TimeUnit.SECONDS.sleep(2);
                }
            } catch (InterruptedException e) {
                log.error("线程错误堆栈信息：{}", e);
            }
            return "1";
        } else {
            throw new Exception("Bad flag");
        }
    }
}

package com.wpw.threadconcurrent;


import lombok.extern.slf4j.Slf4j;


import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;


@Slf4j
public class TestCallable {
    public static void main(String[] args) {
        MyCallable myCallableTask = MyCallable.builder().build();
        myCallableTask.setFlag(new AtomicInteger(0));
        MyCallable myCallableTask2 = new MyCallable();
        myCallableTask2.setFlag(new AtomicInteger(1));
        MyCallable myCallableTask3 = new MyCallable();
        myCallableTask3.setFlag(new AtomicInteger(2));
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        try {
            Future<String> future = executorService.submit(myCallableTask);
            log.info("myCallableTask  result:{}", future.get());
            Future myTask2 = executorService.submit(myCallableTask2);
            TimeUnit.SECONDS.sleep(3);
            System.out.println("myCallableTask2 cancel: " + myTask2.cancel(true));
            Future myTask3 = executorService.submit(myCallableTask3);
            System.out.println("myCallableTask3 result" + myTask3.get());
        } catch (Exception e) {
            log.error("线程堆栈信息:{}", e);
        }
        executorService.shutdownNow();
    }
}

这次要分享的内容文章到这里就结束了，喜欢文章的可以关注和转发。