多线程：2-创建线程方式

2.创建线程方式

创建线程的三种方式

1. 继承Thread类，重写run()方法。
2. 实现Runnable接口，实现run()方法。（推荐使用，因为java单继承的局限性）
3. 实现Callable接口，实现call()方法。
4. 通过线程池创建。

1.Thread

1. 自定义线程类 继承Thread类
2. 重写 run() 方法，编写线程执行体
3. 创建线程对象，调用 start() 方法来启动线程

   // 创建线程
   public class TestThread extends Thread{
       // run方法线程体
       public void run(){
           for (int i = 0; i < 20; i++) {
               System.out.println("run方法线程体" + i);
           }
       }
   }
   
   
   // 测试类
   class Test{
       // main方法 主线程
       public static void main(String[] args) {
           // 调用写好的线程
           TestThread testThread = new TestThread();
           testThread.start();
   
           for (int i = 0; i < 500; i++) {
               System.out.println("main方法 主线程" + i);
           }
       }
   }

结果：

run方法线程体11
run方法线程体12
run方法线程体13
main方法 主线程134
run方法线程体14
main方法 主线程135
main方法 主线程136

2.实现Runnable

1. 定义MyRunnable类 实现 Runnable接口
2. 实现 run()方法 ，编写线程执行体
3. 创建线程对象，调用 start()方法
4. Runnable接口源码（函数式接口，可用lambda表达式）

   @FunctionalInterface
   public interface Runnable {
   	public abstract void run();
   }

简单测试：

// 实现Runnable，实现run()方法
public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("run方法线程体" + i);
        }
    }
}


// 测试类
class Test{
    public static void main(String[] args) {
        // 创建实现类对象
        MyRunnable runnable = new MyRunnable();
        // 创建代理类对象 (静态代理)
        // Thread thread = new Thread(runnable);
        // thread.start();
        new Thread(runnable).start();

        for (int i = 0; i < 500; i++) {
            System.out.println("main方法 主线程" + i);
        }
    }
}

2.1：实现Runnable接口的方式，避免了单继承的局限性，方便同一个对象被多个线程使用。

// 一份资源
MyRunnable runnable = new MyRunnable();

// 多个代理
new Thread(runnable, "张三").start();
new Thread(runnable, "李四").start();
new Thread(runnable, "王二").start();

举例1：模拟买火车票例子。

public class MyRunnable implements Runnable{
    private int ticketNums = 6;

    public void run(){
        while (true){
            if(ticketNums <= 0){
                break;
            }

            // 获取线程名字
            String name = Thread.currentThread().getName();
            System.out.println(name + ":获得了第" + ticketNums + "张票");

            // 模拟延迟
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            // 票数减1
            ticketNums--;
        }
    }
}

// 测试类
class Test{
    public static void main(String[] args) {
        MyRunnable runnable = new MyRunnable();

        new Thread(runnable, "张三").start();
        new Thread(runnable, "李四").start();
        new Thread(runnable, "王二").start();
    }
}

结果：同一张票被多人抢到 （多线程操作同一资源的情况下，线程不安全，数据紊乱）

李四:获得了第6张票
王二:获得了第6张票
王二:获得了第5张票
李四:获得了第4张票
张三:获得了第3张票
李四:获得了第2张票
王二:获得了第1张票
张三:获得了第2张票

举例2：模拟龟兔赛跑

// 模拟龟兔赛跑（谁先跑到100步谁胜利）
public class Race implements Runnable {

    // 胜利者
    private static String winner;

    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {

            // 模拟兔子休息（兔子每10步 休息10ms）
            if(Thread.currentThread().getName().equals("兔子") && i%10 == 0){
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            // 判断比赛是否结束(结束就退出线程)
            boolean flag = gameOver(i);
            if(flag){
                break;
            }

            System.out.println(Thread.currentThread().getName() + "跑了：" + i + "步");
        }
    }

    // 判断是否完成比赛
    private boolean gameOver(int steps) {
        if(winner != null){
            return true;
        }

        if(steps >= 100){
            winner = Thread.currentThread().getName();
            System.out.println("Winner is " + winner);
            return true;
        }

        return false;
    }
}

class Test{
    public static void main(String[] args) {
        Race race = new Race();

        new Thread(race, "兔子").start();
        new Thread(race, "乌龟").start();
    }
}

结果：

兔子跑了：9步
乌龟跑了：96步
乌龟跑了：97步
乌龟跑了：98步
乌龟跑了：99步
Winner is 乌龟

3.Callable

1. 实现Callable接口，需要返回值类型。
2. 重写call()方法，需要抛出异常
3. 创建目标对象
4. 创建执行服务：ExecutorService ser = Executors.newFixedThreadPool(2);
5. 提交执行：Future resul1 = ser.submit(t1);
6. 获取结果：boolean r1 = resul1.get();
7. 关闭服务：ser.shutdownNow();

例：

public class TestCallable implements Callable<Boolean> {

    @Override
    public Boolean call() throws Exception {

        for (int i = 0; i < 20; i++) {
            System.out.println("run方法线程体" + i);
        }

        return true;
    }
}

class Test{
    public static void main(String[] args) throws Exception {
        TestCallable t1 = new TestCallable();
        TestCallable t2 = new TestCallable();

        // 创建执行服务 (创建2个线程)
        ExecutorService ser = Executors.newFixedThreadPool(2);

        // 提交执行 (启动线程)
        Future<Boolean> resul1 = ser.submit(t1);
        Future<Boolean> resul2 = ser.submit(t2);

        // 获取结果
        boolean r1 = resul1.get();
        boolean r2 = resul2.get();

        // 关闭服务
        ser.shutdownNow();
    }
}

赏

失败是成功之母

支付宝

微信