java多线程 创建方式详解

java多线程篇 创建方式

---

前言

什么是线程

线程（Thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。在Unix System V及SunOS中也被称为轻量进程（Lightweight Process），但轻量进程更多指内核线程（Kernel-Level Thread），而把用户线程（User-Level Thread）称为线程。

线程是独立调度和分派的基本单位。线程可以为操作系统内核调度的内核线程，如Win32线程；由用户进程自行调度的用户线程，如Linux平台的POSIX Thread，Java线程。

线程作为调度和分配的基本单位，许多多线程程序可以同时运行于一个进程中，共享相同的上下文和内存空间。这使得线程间的通信比进程间的通信更加高效。但是，多线程编程也需要注意线程安全和资源竞争等问题。

多线程创建第一种创建方式

public class demo1 {
    public static void main(String[] args) {
        /**
         * 创建线程的第一种方式
         * */
        Mythread mythread = new Mythread();
        mythread.start();//启动线程
    }
}

public class Mythread extends Thread{
    public void run(){
        System.out.println("Thread is running");
    }
}

通过继承Thread重写它的run方法，然后在主方法内调用Mythread的对象，启动线程即可得到里面的数据。

public class demo1 {
    public static void main(String[] args) {
        /**
         * 创建线程的第一种方式
         * */
        Mythread mythread = new Mythread();
        Mythread mythread1=new Mythread();
        mythread1.setName("你好,我是线程二");
        mythread.setName("你好,我是线程一");
        mythread.start();//启动线程
        mythread1.start();
    }
}

public class Mythread extends Thread{
    public void run(){
        System.out.println( getName()+"Thread is running");
    }
}

我们创建了2个线程，如果我们for循环多次就会发现他是不断进行交替的

多线程创建的第二种方式

继承Runnable接口实现多线程

public class demo1 {
    public static void main(String[] args) {
        /**
         * 创建线程的第二种方式，继承Runnable接口
         * */
        System.out.println("继承Runnable接口创建线程");
        MyRun myRun = new MyRun();
        //创建线程对象
        Thread thread = new Thread(myRun);
        Thread thread1 = new Thread(myRun);
        //设置线程的名字
        thread.setName("线程1");
        thread1.setName("线程2");
        //开启线程
        thread.start();
        thread1.start();
    }
}

public class MyRun implements Runnable {
    public void run()
    {
        for (int i = 0; i < 20; i++) {
            System.out.println( Thread.currentThread().getName() + "Runnable");
        }
    }
}

• 由于我们不是直接继承线程对象而是继承Runnable对象，所以我们要拿到他的名字需要得到线程对象再getName（Thread.currentThread().getName()）

第三种创建方式（有返回值）

• 继承callable类,然后重写call方法
• 使用FutureTask管理callable的子类实现对象
• 创建线程运行
• 通过FutureTask对象拿到处理结果

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

public class demo1 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        /**
         * 创建线程的第三种方式，继承callable接口
         * 使用FutureTask类管理callable对象
         * 创建线程，运行
         * */
        Mycallable mycallable = new Mycallable();
        //放入FutureTask管理
        FutureTask<Integer> futureTask = new FutureTask<>(mycallable);
        //创建线程
        Thread thread = new Thread(futureTask);
        thread.start();
        Integer integer = futureTask.get();//获取线程执行结果
        System.out.println(integer);
    }
}

import java.util.concurrent.Callable;

public class Mycallable   implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            sum=sum+i;
        }
        return sum;
    }
}

三种实现方式的对比

常见的实现方法