Java多线程的应用

多线程的调动是随着cpu调度的，可以给线程设置优先级，但最终还是要依靠CPU的调度，无法确定线程的执行顺序。

多线程的实现方法

继承Thread类，重写run（）方法，调用start开始线程；
实现Runnable接口，重写run()方法，执行线程需要丢入Runnable实现接口类，调用start方法；
实现Callable接口，并用其初始化Thread，然后创建Thread实例，并调用start方法。

详细说明

继承Thread类

//创建线程方式一：继承Thread类，重写run（）方法，调用start开始线程
public class demo1 extends Thread {
    @Override
    public void run() {         //重写run方法
        for (int i = 0; i <= 99; i++) {
            System.out.println(i+"在学习多线程");
        }
    }
    public static void main(String[] args) {

        demo1 thread = new demo1();     
        thread.start();                 //启动run方法

        for (int i = 0; i <= 99; i++) {
            System.out.println("主方法"+i+"也在学习多线程");
        }
    }
}

Thread本质上也是实现了Runnable接口的一个实例，它代表一个线程的实例，启动线程的唯一方法就是通过Thread类的start()实例方法。执行结果是随着cpu调度的，可以给线程设置优先级，但最终还是要依靠CPU的调度，无法确定线程的执行顺序。

实现Runnable接口

public class demo4 implements Runnable {
    private int ticketNum = 10;

    @Override
    public void run() {     //重写run方法
        while (true){
            if (ticketNum<=0){
                break;
            }
            System.out.println(Thread.currentThread().getName() + "拿走了第"+ ticketNum + "票。");
            ticketNum--;
        }
    }
    public static void main(String[] args) {
        demo4 t1 = new demo4();
        demo4 t2 = new demo4();
        demo4 t3 = new demo4();

        new Thread(t1,"Jeri").start();      //执行线程
        new Thread(t2,"Jordon").start();
        new Thread(t3,"Knight").start();
    }
}

当自己的类已经继承（extends）了另一个类，就无法再次extends Thread。此时，必须实现一个Runnable接口，如上所示。但实现Runnable接口的线程执行与extends Thread有所不同，需要new一个Thread对象，再把线程丢入，最后start.

举一个龟兔赛跑的例子，乌龟不停跑，兔子偶尔会休息：

//龟兔赛跑模拟
public class demo5_race implements Runnable {
    private static String winner;
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            //如果是兔子，就让他休息1ms，下面的条件表示的是i是10的倍数时兔子再休息
            if (Thread.currentThread().getName().equals("兔子") && i % 10 ==0){
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //判断是否有胜利者出现了
            boolean flag = gameOver(i);
            if (flag){
                break;
            }
            System.out.println(Thread.currentThread().getName() + "跑了" + i + "步");
        }
    }
    //判断比赛是否结束了
    public boolean gameOver(int step){
        if (winner != null){
            return true;
        }{
            if (step >= 100){
                winner = Thread.currentThread().getName();
                System.out.println(winner + " is winner!");
                return true;
            }
        }
        return false;
    }
    //主函，两个线程
    public static void main(String[] args) {
        demo5_race race = new demo5_race();
        new Thread(race,"乌龟").start();
        new Thread(race,"兔子").start();
    }
}

当使用Thread.sleep()方法时，就模拟了兔子的休息。此时乌龟仍然在跑。运行结果自然就大概率是乌龟是赢家。

实现Callable接口

package thread;

import java.util.concurrent.*;

public class demo6_callable implements Callable<Boolean> {
    @Override
    public Boolean call() throws Exception {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"call方法的线程正在跑...");
        }
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"主方法的线程...");
        }

        demo6_callable demo6 = new demo6_callable();

        //创建执行服务
        ExecutorService ser = Executors.newFixedThreadPool(3);
        //提交执行
        Future<Boolean> sub = ser.submit(demo6);
        //获取结果
        Boolean aBoolean = sub.get();
        //关闭服务
        ser.shutdown();
    }
}