一文入门多线程知识

多线程

---

线程与进程

进程

• 指一个内存中运行的应用程序，每个进程都有一个独立的内存空间。

线程

• 是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行。一个进程最少有一个线程。
• 线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程。

---

线程调度

分时调度

• 所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间。

抢占式调度

• 优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个线程使用CPU（线程随机性），Java使用抢占式调度。
• CPU使用抢占式调度模式在多个线程间进行高速的切换。对于CPU的一个核心而言，某个时刻，只能执行一个线程，而CPU在多个线程间的切换速度比较快，看上去像是在同一时刻运行。其实，多线程并不能提高程序的运行效率，让CPU的使用率更高。

---

同步 与 异步

同步：排队执行，效率低但是安全

异步：同时执行，效率高但是不安全

---

并发 与 并行

并发：指两个或多个事件在同一时间段内发生

并行：指两个或多个事件在同一时刻发生（同时发生）

---

线程的使用

继承 Thread

public class MyThread extends Thread{
   
    /**
     * run 方法就是线程要执行的任务方法
     */
    @Override
    public void run() {
   
        // 这里的代码，就是一条新的执行路径
        // 这个执行路径的出发方式，不是调用run方法，而是通过start方法来启动任务
        for (int i=0; i<10; i++){
   
            System.out.println("天南地北" + i);
        }
    }
}

/**
* 执行的主程序
*/
public class Demo {
   
    /**
     * 多线程技术
     * @param args
     */
    public static void main(String[] args) {
   
        // 程序启动 - main线程开启 - main方法执行 - 创建m对象 - m线程开启 - 程序结束
        // 每个线程都拥有自己的栈空间，共用一份堆内存
        MyThread m = new MyThread();
        m.start();
        for (int i=0; i<10; i++){
   
            System.out.println("懂得都懂" + i);
        }
    }
}

// ----------------------------------------------------------------------------------------------------------
public class Demo2 {
   
    public static void main(String[] args) {
   
        // 匿名内部类写法
        new Thread(){
   
            @Override
            public void run() {
   
                for (int i=0; i<10; i++){
   
                    System.out.println("一二三四五" + i);
                }
            }
        }.start();
        for (int i=0; i<10; i++){
   
            System.out.println("六七八九十" + i);
        }
    }
}

实现 Runnable

/**
 * 用于给线程执行的任务
 */
public class MyRunnable implements Runnable{
   
    @Override
    public void run() {
   
        // 线程的任务
        for (int i=0; i<10; i++){
   
            System.out.println("咚咚咚咚" + i);
        }
    }
}

/**
* 执行的主程序
*/
public class DemoR {
   
    public static void main(String[] args) {
   
        // 实现Runnable
        // 1. 创建一个任务对象
        MyRunnable r = new MyRunnable();
        // 2. 创建一个线程，并为其分配一个任务
        Thread t = new Thread(r);
        // 3. 执行这个线程
        t.start();
        for (int i=0; i<10; i++){
   
            System.out.println("嘻嘻嘻嘻" + i);
        }
    }
}

实现Runnable 与 继承Thread相比具有如下优势：

1. 通过创建任务，然后给线程分配的方式来实现多线程，更适合多个线程同时执行相同任务的情况
2. 可以避免单继承所带来的局限性
3. 任务与线程本身是分离的，提高了程序的健壮性
4. 线程池技术，接受Runnable类型的任务，不接受Thread类型的线程

带返回值的线程 Callable

// 使用步骤
1. 编写类实现Callable接口，实现call方法
class XXX implements Callable<T>{
   
  	@Override
  	public <T> call() throws Exception {
   
      	return T;
    }
}
2. 创建FutureTask对象，并传入第一步编写的Callable类对象
	 FutureTask<Integer> future = new FutureTask<>(callable);
3. 通过Thread，启动线程
   new Thread(future).start();

Runnable 与 Callable

接口定义
// Callable 接口
public interface Callable<V> {
   
  	V call() throws Exception;
}

// Runnable 接口
public interface Runnable {
   
  	public abstract void run();
}
// ---------------------------------------------------------------------------------------------------------
// Callable 例子
public class Demo7Callable {
   
    public static void main(String[] args) throws ExecutionException, InterruptedException {
   
        Callable<Integer> c = new MyCallable();
        FutureTask<Integer> task = new FutureTask<>(c);
        new Thread(task).start();
        Integer j = task.get();
        // 先执行子线程，后打印返回值，最后执行主线程
        System.out.println("返回值为：" + j);
        for (int i=0; i<10; i++){
   
            try {
   
                Thread.sleep(100);
            } catch (InterruptedException e) {
   
                e.printStackTrace();
            }
            System.out.println(i);
        }
    }

    static class MyCallable implements Callable<Integer>{
   
        @Override
        public Integer call() throws Exception {
   
//            Thread.sleep(3000);
            for (int i=0; i<10; i++){
   
                Thread.sleep(100);
                System.out.println(i);
            }
            return 100;
        }
    }
}

Runnable 与 Callable的相同点

• 都是接口
• 都可以编写多线程程序
• 都采用Thread.start()启动线程

Runnable 与 Callable的不同点

• Runnable没有返回值；Callable可以返回执行结果
• Callable接口的call()允许抛出异常；Runnable的run()不允许抛出

获取线程名称

public class Demo3GetName {
   
    public static void main(String[] args) {
   
        // 如何获取线程的名称
        // currentThread() - 获取当前的线程
        System.out.println(Thread.currentThread