Java多线程（一）——多线程基本概念、线程创建方式

Java多线程（一）

一、程序、进程、线程基本概念

程序：是为完成特定任务，用某种语言编写的一组指令的集合，即指一段静态的代码，静态对象。
进程：是程序的一次执行过程，或是正在运行的一个程序，是一个动态的过程，有它自身的产生，存在和消亡的过程。
线程：线程是操作系统能够进⾏运算调度的最⼩单位，它被包含在进程之中，是进程中的实际运作单位，可以使⽤多线程对
进⾏运算提速。

二、并发、并行基本概念

并行：多个CPU同时执行多个任务。多个cpu实例或者多台机器同时执行一段处理逻辑。
并发：一个CPU（采用时间片）同时执行多个任务。通过cpu调度算法，让用户看上去同时执行，实际上从cpu操作层面不是真正的同时。

三、Java多线程基本状态及生命周期

多线程有五种基本状态，分别是新建状态、就绪状态，运行状态，死亡状态，阻塞状态。

线程的基本状态：

• 新建 ：从新建一个线程对象到程序start() 这个线程之间的状态，都是新建状态；
• 就绪 ：线程对象调用start()方法后，就处于就绪状态，等到JVM里的线程调度器的调度；
• 运行 ：就绪状态下的线程在获取CPU资源后就可以执行run(),此时的线程便处于运行状态，运行状态的线程可变为就绪、阻塞及死亡三种状态。
• 等待/阻塞/睡眠 ：在一个线程执行了sleep（睡眠）、suspend（挂起）等方法后会失去所占有的资源，从而进入阻塞状态，在睡眠结束后可重新进入就绪状态。
• 终止 ：run（）方法完成后或发生其他终止条件时就会切换到终止状态。

四、Java多线程常用方法

1. start():1.启动当前线程2.调用线程中的run方法
2. run():通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
3. currentThread():静态方法，返回执行当前代码的线程
4. getName():获取当前线程的名字
5. setName():设置当前线程的名字
6. yield():主动释放当前线程的执行权
7. join():在线程中插入执行另一个线程，该线程被阻塞，直到插入执行的线程完全执行完毕以后，该线程才继续执行下去
8. stop():过时方法。当执行此方法时，强制结束当前线程。
9. sleep（long millitime）：线程休眠一段时间
10. isAlive（）：判断当前线程是否存活

五、多线程创建方式

（一）继承Thread类：

1. 创建一个集成于Thread类的子类
2. 重写Thread类的run( )方法
3. 创建Thread子类的对象
4. 通过此对象调用start( )方法

start( )方法与run( )方法的区别：

start( )方法：

​ 用start方法来启动线程，真正实现了多线程运行，这时无需等待run方法体代码执行完毕而直接继续执行下面的代码。通过调用Thread类的start()方法来启动一个线程，这时此线程处于就绪（可运行）状态，并没有运行，一旦得到cpu时间片，就开始执行run()方法，这里方法run()称为线程体，它包含了要执行的这个线程的内容，run方法运行结束，此线程随即终止。

Java源码start( )方法：

		public synchronized void start() {
        if (threadStatus != 0)
            throw new IllegalThreadStateException();
  
        group.add(this);

        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
                /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
            }
        }
    }

    private native void start0();

run( )方法：

run()方法只是类的一个普通方法而已，如果直接调用Run方法，程序中依然只有主线程这一个线程，其程序执行路径还是只有一条，还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码，这样就没有达到写线程的目的。

Java源码run( )方法：

		@Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }

Thread创建线程实例：

public class Main {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();

        t1.setName("t1");
        t2.setName("t2");

        t1.start();
        t2.start();

        //使用lambda表达式简化
        new Thread(()->{
            int i = 0;
            while(true){
                System.out.println(Thread.currentThread().getName()+"线程"+i++);
            }
        }).start();
    }
}

class MyThread extends Thread{
    int i = 0;

    @Override
    public void run() {
        while(true){
            System.out.println(Thread.currentThread().getName()+"线程"+i++);
        }
    }
}

（二）实现Runable接口：

1. 创建一个实现了Runable接口的类
2. 实现类去实现Runnable中的抽象方法：run()
3. 创建实现类的对象
4. 将此对象作为参数传递到Thread类中的构造器中，创建Thread类的对象
5. 通过Thread类的对象调用start（）

实现Runable接口实例：

public class RunnableTest {
    public static void main(String[] args) {
        MyRunnable m1 = new MyRunnable();
        Thread t1 = new Thread(m1);
        Thread t2 = new Thread(m1);

        t1.start();
        t2.start();

        //局部内部类
        class Test2 implements Runnable{
            @Override
            public void run() {
                for(int i=0;i<5;i++) {
                    System.out.println("局部内部类");
                }
                System.out.println("-------------");
            }
        }
        new Thread(new Test2()).start();

        //匿名内部类
        new Thread(new Runnable(){
            @Override
            public void run() {
                for(int i=0;i<5;i++) {
                    System.out.println("匿名内部类");
                }
                System.out.println("-------------");
            }
        }).start();
    }
}

class MyRunnable implements Runnable{
    @Override
    public void run() {
            for(int i=0;i<5;i++){
                System.out.println(Thread.currentThread().getName()+"线程"+i++);
            }
        }
    }

（三）实现callable接口：

与实现Runable接口相比：

1. runnable重写的run方法不如callaalbe的call方法强大，call方法可以有返回值
2. 方法可以抛出异常
3. 支持泛型的返回值
4. 需要借助FutureTask类，比如获取返回结果

使用Callable创建线程：

1. 创建一个实现callable的实现类
2. 实现call方法，将此线程需要执行的操作声明在call（）中
3. 创建callable实现类的对象
4. 将callable接口实现类的对象作为传递到FutureTask的构造器中，创建FutureTask的对象
5. 将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start方法启动（通过FutureTask的对象调用方法get获取线程中的call的返回值）

实现callable接口实例：

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

public class CallableTest {
    public static void main(String[] args){
        //new一个实现callable接口的对象
        NumThread numThread = new NumThread();

        //通过futureTask对象的get方法来接收futureTask的值
        FutureTask futureTask = new FutureTask(numThread);

        Thread t1 = new Thread(futureTask);
        t1.setName("线程1");
        t1.start();

        try {
            //get返回值即为FutureTask构造器参数callable实现类重写的call的返回值
            Object sum = futureTask.get();
            System.out.println(Thread.currentThread().getName()+":"+sum);
        } catch (ExecutionException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
class NumThread implements Callable {

    private int sum=0;//

    @Override
    public Object call() throws Exception {
        for(int i=0;i<5;i++){
            sum += i;
            System.out.println(Thread.currentThread().getName()+"线程"+i++);
        }
        return sum;
    }
}