多线程的实现方式

多线程的实现方案

• 继承Thread类的方式进行实现
• 实现Runnable接口的方式进行实现
• 利用Callable和Future接口方式实现

方案1：继承Thread类

• 定义一个类MyThread继承Thread类
• 在MyThread类中重写run()方法
• 创建MyThread类的对象
• 启动线程

创建一个简单的线程

public class MyThread extends Thread{
    @Override
    public void run() {
        //代码就是线程在开启之后执行的代码
        for (int i = 0; i < 100; i++) {
            System.out.println("线程开启了"+i);
        }
    }
}

public class Demo {
    public static void main(String[] args) {
        //创建MyThread对象
        MyThread t1 = new MyThread();
        //开启线程
        t1.start();
    }
}

开启一条线程时控制台打印出来的结果按照顺序从1到100

当程序开启第二条线程

public class Demo {
    public static void main(String[] args) {
        //创建一个线程对象
        MyThread t1 = new MyThread();
        //创建一个线程对象
        MyThread t2 = new MyThread();
        //开启线程
        t1.start();
        //开启第二条线程
        t2.start();
    }
}

可以看出来程序在执行的时候两条线程是在交替执行

两个小问题

• 继承Thread类为什么要重写run()方法
  多线程在开启后执行的就是run()方法里面的代码，run()方法就是用来封装线程执行的代码的。
• run()方法和start()方法的区别
  run()方法：封装线程执行的代码，直接调用，相当于普通方法的调用，并没有开启线程。
  start()方法：启动线程；然后由JVM调用此线程的run()方法。

方案2：实现Runnable接口

• 定义一个类MyRunnable实现Runnable接口
• 在MyRunnable类中重写run()方法
• 在测试类中创建MyRunnable类的对象
• 创建Thread类的对象，把MyRunnable类的对象作为构造方法的参数
• 启动线程

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        //线程启动后执行的代码
        for (int i = 0; i < 100; i++) {
            System.out.println("线程开始执行了"+i);
        }
    }
}

public class Demo {
    public static void main(String[] args) {
        //创建了一个参数对象
        MyRunnable mr = new MyRunnable();
        //创建了一个线程对象，并把参数传递给这个线程，
        //在线程启动之后，执行的就是参数里面的run()方法
        Thread t1 = new Thread(mr);
        //开启线程
        t1.start();


        MyRunnable mr2 = new MyRunnable();
        //创建了一个线程对象，并把参数传递给这个线程，
        //在线程启动之后，执行的就是参数里面的run()方法
        Thread t2 = new Thread(mr2);
        //开启线程
        t2.start();
    }
}

方案3：Callable和Future

• 定义一个类MyCallable实现Callable接口
• 在MyCallable类中重写call()方法
• 在测试类中创建MyCallable类的对象
• 创建Future的实现类FutureTask对象，把MyCallable对象座位构造方法的参数
• 创建Thread类的对象，把FutureTask对象作为构造方法的参数
• 启动线程
• 再调用get()方法，就可以获取线程结束之后的结果

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println("跟老师请假"+i);
        }

        //返回值就表示线程运行完毕之后的结果
        return "成功";
    }
}

public class Demo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //线程开启之后需要执行里面的call()方法
        MyCallable mc = new MyCallable();
        //可以获取线程执行完毕之后的结果，也可以作为传递参数传递给Thread对象
        FutureTask<String> ft = new FutureTask<>(mc);
        //创建线程对象
        Thread t1 = new Thread(ft);

        //开启线程
        t1.start();

        String s = ft.get(); //get方法获取线程运行之后的结果，如果线程还没有运行结束，那么get方法会在这里死等
        System.out.println(s);
    }
}

三种实现方式的简单对比

	优点	缺点
实现Runnable、Callable接口	扩展性强，实现该接口的同时还可以继承其他的类。	编程相对复杂，不能直接使用Thread类中的方法
继承Thread类	编程比较简单，可以直接使用Thread类中的方法。	拓展性较差，不能再去继承其他的类

Thread类中的常见方法

获取和设置线程名称

获取线程的名字

• String getName(); 返回线程的名称

public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+"————"+i);
        }
    }
}

public class Demo {
    //线程是有默认名字的，格式：Thread-编号
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        t1.start();
        t2.start();
    }
}

Thread类中设置线程的名字

• void setName(String name); 将此线程的名称更改为等于参数name

public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+"————"+i);
        }
    }
}

public class Demo {
    //线程是有默认名字的，格式：Thread-编号
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();

        t1.setName("小美");
        t2.setName("王大锤");

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

• 通过构造方法也可以设置线程名称

public class MyThread extends Thread{

    public MyThread() {
    }

    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+"————"+i);
        }
    }
}

public class Demo {
    //线程是有默认名字的，格式：Thread-编号
    public static void main(String[] args) {
        MyThread t1 = new MyThread("小美");
        MyThread t2 = new MyThread("王大锤");

        /*t1.setName("小美");
        t2.setName("王大锤");*/

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

获得当前线程的对象

• public static Thread currentThread(); 返回对当前正在执行的线程对象的引用

public class Demo {
    public static void main(String[] args) {
		//获取当前线程的对象，利用当前线程的对象调用getName的方法去获取线程的名字
        String name = Thread.currentThread().getName();
        System.out.println(name);
    }
}

线程休眠

• public static void sleep(long time); 让线程休眠指定的时间，单位为毫秒。

public class MyRunnable implements Runnable{
    
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName()+"-----"+i);
        }
    }
}

public class Demo {
    public static void main(String[] args) throws InterruptedException {
       /* System.out.println("睡觉前");
        Thread.sleep(3000);
        System.out.println("睡醒了");*/

        MyRunnable mr = new MyRunnable();
        MyRunnable mr2 = new MyRunnable();

        Thread t1 = new Thread(mr);
        Thread t2 = new Thread(mr2);

        t1.setName("小美");
        t2.setName("大锤");

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

线程的优先级

线程调度

• 多线程的并发运行：计算机中的cpu，在任意时刻只能执行一条机器指令。每个线程只有获得cpu的使用权才能执行代码。各个线程轮流获得cpu的使用权，分别执行各自的任务。

线程有两种调度模型

• 分时调度模型：所有线程轮流使用cpu的使用权，平均分配每个线程占用cpu的时间片
• 抢占式调度模型：优先让优先级高的线程使用cpu，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取cpu时间片相对多一些

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"-----"+i);
        }
        return "线程执行完毕了";
    }
}

public class Demo {
    public static void main(String[] args) {
        MyCallable mc = new MyCallable();

        FutureTask<String> ft = new FutureTask<>(mc);

        Thread t1 = new Thread(ft);
        t1.setName("飞机");
        t1.setPriority(10);
        //System.out.println(t1.getPriority());
        t1.start();


        MyCallable mc2 = new MyCallable();

        FutureTask<String> ft2 = new FutureTask<>(mc2);

        Thread t2 = new Thread(ft2);
        t2.setName("坦克");
        t2.setPriority(1);
        //System.out.println(t2.getPriority());
        t2.start();
    }
}

守护线程

• public final void setDaemon(boolean on); 设置为守护线程

public class MyThread1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"-----"+i);
        }
    }
}

public class MyThread2 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"-----"+i);
        }
    }
}

public class Demo {
    public static void main(String[] args) {
        MyThread1 t1 = new MyThread1();
        MyThread2 t2 = new MyThread2();

        t1.setName("女神");
        t2.setName("备胎");

        //把第二个线程设置为守护线程
        //当普通线程执行完之后，那么守护线程也没有运行下去的必要了
        t2.setDaemon(true);

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