Java 中多线程

1: 概念

进程:

进程是指在系统中正在运行的一个应用程序.每个进程之间是独立的,每个进程均运行在其专用且受保护的内存空间内.
例如, 平时打开的酷狗音乐听歌, 就是一个进程.

(多)线程:

线程有时被称为轻量进程(Lightweight Process,LWP),是程序执行流的最小单元.
线程是程序中一个单一的顺序控制流程.进程内有一个相对独立的、可调度的执行单元,是系统独立调度和分派CPU的基本单位指令运行时的程序的调度单位.在单个程序中同时运行多个线程完成不同的工作,称为多线程.

进程&线程关系:

进程想要执行任务,必须有线程(每一个进程至少要有一条线程);
线程是进程的执行单元,一个进程(程序)的所有任务都在线程中执行.
通常, 线程中的任务的执行都是串行的, 在一个时间内, 一个线程只能执行一个任务.

为什么要多线程:

可以在一个进程中开启多条线程, 每条线程可以并行(同行)执行不同的任务,充分利用CPU,适当的提高程序的执行效率.

2: 多线程中常用方法

方法	说明
currentThread	返回当前正在执行的线程对象的应用
start	使该线程开始执行；Java 虚拟机调用该线程的 run 方法. 注意, 不要调用run方法启动线程, 启动线程是start, 如果调用run方法, 相当于在主线程中调用run方法, 和普通的方法的调用没有区别, 此时不会创建一个新的线程来执行定义的任务
run	如果该线程是使用独立的Runnable运行对象构造的,则调用该Runnable对象的run方法;否则,该方法不执行任何操作并返回.
setName	改变线程名称,使之与参数name相同.
setPriority	改变线程的优先级
setDeamon	设置线程为守护线程或用户线程
interrupt	中断线程
isAlive	测试线程是否处于活动状态.
yield	暂停当前正在执行的线程对象, 并执行其他线程
sleep	让当前正在执行的线程休眠指定的毫秒数

3: 如何创建线程

1: 普通创建 Thread() 对象
2: 继承 Thread 类
3: 实现 Runnable 接口
4: 实现 Callable 接口, 实现Callable接口后, 可以有返回值

4: 实例讲解多线程

例子1(new Thread):

//================Demo1
public class Demo1 {
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread("thread1");
        thread1.sleep(5000);
        System.out.println("线程名称: " + thread1.currentThread().getName());

        Thread thread2 = new Thread("thread2");
        thread2.sleep(5000);
        System.out.println("线程名称: " + thread2.currentThread().getName());
    }
}

//================Demo2
public class Demo2 {
    public static void main(String[] args) {
        Thread thread1 = new Thread("Thread1"){
            public void run() {
                try {
                    Thread.sleep(5000);
                    System.out.println("线程名称: " + Thread.currentThread().getName());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            };
        };
        thread1.start();

        Thread thread2 = new Thread("Thread2"){
            public void run() {
                try {
                    Thread.sleep(5000);
                    System.out.println("线程名称: " + Thread.currentThread().getName());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            };
        };
        thread2.start();
    }
}

认真体会一下上面2个demo, 想一想, 他们执行完所花的时间一样都是10毫秒吗?
答案是否定的, Demo1执行时间10毫秒, Demo2执行时间为5毫秒. why?
因为第一个是在同一个主线程中. 打印的结果可以看到

Demo1:
线程名称: main
线程名称: main

Demo2:
线程名称: Thread2
线程名称: Thread1

例子2(extend Thread):

public class Main {
    public static void main(String[] args) {
        for (int i=0; i< 5; i++){
            Thread thread = new MyThread();
            thread.start();
        }
    }
}

public class MyThread extends Thread{
    DateFormat df = new SimpleDateFormat("yyyy年MM月dd日HH时mm分ss秒S毫秒");

    @Override
    public void run() {
        String name = Thread.currentThread().getName();
        System.out.println(df.format( new Date()) + " Thread:" + name + " start.");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(df.format( new Date()) + " Thread:" + name + " end.");
    }
}

===============以下是执行结果
2018年09月25日18时35分10秒913毫秒 Thread:Thread-0 start.
2018年09月25日18时35分10秒914毫秒 Thread:Thread-1 start.
2018年09月25日18时35分10秒915毫秒 Thread:Thread-2 start.
2018年09月25日18时35分10秒916毫秒 Thread:Thread-3 start.
2018年09月25日18时35分10秒916毫秒 Thread:Thread-4 start.
2018年09月25日18时35分15秒914毫秒 Thread:Thread-1 end.
2018年09月25日18时35分15秒914毫秒 Thread:Thread-0 end.
2018年09月25日18时35分15秒916毫秒 Thread:Thread-2 end.
2018年09月25日18时35分15秒916毫秒 Thread:Thread-4 end.
2018年09月25日18时35分15秒916毫秒 Thread:Thread-3 end.

例子3(实现Runnable接口):

public class Main {
    public static void main(String[] args) {
        for(int i=0; i<5; i++){
            Thread thread = new Thread(new MyRunnable());
            thread.start();
        }
    }
}

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        String name = Thread.currentThread().getName();
        DateFormat df = new SimpleDateFormat("yyyy年MM月dd日HH时mm分ss秒S毫秒");

        System.out.println(df.format(new Date()) + " Thread:" + name + " start.");
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(df.format(new Date()) + " Thread:" + name + " end.");
    }
}
//===================结果, 也是只花了10秒
2018年09月25日18时41分43秒255毫秒 Thread:Thread-4 start.
2018年09月25日18时41分43秒255毫秒 Thread:Thread-2 start.
2018年09月25日18时41分43秒255毫秒 Thread:Thread-0 start.
2018年09月25日18时41分43秒255毫秒 Thread:Thread-1 start.
2018年09月25日18时41分43秒260毫秒 Thread:Thread-3 start.
2018年09月25日18时41分53秒257毫秒 Thread:Thread-4 end.
2018年09月25日18时41分53秒258毫秒 Thread:Thread-2 end.
2018年09月25日18时41分53秒258毫秒 Thread:Thread-0 end.
2018年09月25日18时41分53秒258毫秒 Thread:Thread-1 end.
2018年09月25日18时41分53秒262毫秒 Thread:Thread-3 end.

例子4(实现Callable接口):
实现callable之后, 如果有返回值的话, 就需要放到线程池中, 待全部执行完了, 一起返回.

public class Main {
    public static void main(String[] args) {
        int poolsize = 3;
        Date start = new Date();
        List<Future> list = new ArrayList<Future>();

        ExecutorService pool  = Executors.newFixedThreadPool(poolsize);
        for(int i =0; i<poolsize; i++){
            Callable thread = new MyCallable();
            Future result = pool.submit(thread);
            list.add(result);
        }
        pool.shutdown();

        list.forEach(item -> {
            try {
                System.out.println("线程返回值为: " + item.get().toString());
            } catch (Exception e) {
                e.printStackTrace();
            }
        });

        Date end = new Date();
        long sec = end.getTime() - start.getTime();
        System.out.println("总共花费: " + sec + " 毫秒!");
    }
}

public class MyCallable implements Callable {
    @Override
    public Object call() throws Exception {
        DateFormat df = new SimpleDateFormat("yyyy年MM月dd日HH时mm分ss秒S毫秒");
        String name = Thread.currentThread().getName();

        System.out.println(df.format(new Date()) + " Thread:" + name + " start.");
        Thread.sleep(10000);
        System.out.println(df.format(new Date()) + " Thread:" + name + " end.");

        return name;
    }
}

//===================结果, 也是只花了10秒
2018年09月25日18时45分54秒713毫秒 Thread:pool-1-thread-2 start.
2018年09月25日18时45分54秒716毫秒 Thread:pool-1-thread-3 start.
2018年09月25日18时45分54秒716毫秒 Thread:pool-1-thread-1 start.
2018年09月25日18时46分04秒714毫秒 Thread:pool-1-thread-2 end.
2018年09月25日18时46分04秒717毫秒 Thread:pool-1-thread-3 end.
2018年09月25日18时46分04秒717毫秒 Thread:pool-1-thread-1 end.
线程返回值为: pool-1-thread-1
线程返回值为: pool-1-thread-2
线程返回值为: pool-1-thread-3
总共花费: 10051 毫秒!