Java 多线程学习-多线程实现

1 实现方法一：继承Thread类

1.1 继承Thread并重写run方法，并调用start方法

public class Thread1 extends Thread {
    
    

    @Override
    public void run() {
    
    
        System.out.println("Thread-run:"+ Thread.currentThread().getName());
    }

    public static void main(String[] args) {
    
    
        Thread1 thread1 = new Thread1();
        thread1.start();
    }
}

• 使用多线程下载：

public class Thread2 extends Thread {
    
    
    private String URL;
    private String NAME;

    public Thread2(String url, String name) {
    
    
        this.URL = url;
        this.NAME = name;
    }

    @Override
    public void run() {
    
    
        DownloadFile downloadFile = new DownloadFile();
        downloadFile.download(URL, NAME);
        System.out.println("当前下载"+ NAME);
    }

    public static void main(String[] args) {
    
    
        Thread2 thread1 = new Thread2("https://ns-strategy.cdn.bcebos.com/ns-strategy/upload/fc_big_pic/part-00506-3665.jpg", "C:\\Users\\Administrator\\Desktop\\1.jpg");
        Thread2 thread2 = new Thread2("https://ss0.bdstatic.com/70cFuHSh_Q1YnxGkpoWK1HF6hhy/it/u=2312275149,1958362117&fm=26&gp=0.jpg", "C:\\Users\\Administrator\\Desktop\\2.jpg");
        Thread2 thread3 = new Thread2("https://ss3.bdstatic.com/70cFv8Sh_Q1YnxGkpoWK1HF6hhy/it/u=2129748033,2752531156&fm=26&gp=0.jpg", "C:\\Users\\Administrator\\Desktop\\ 3.jpg");
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

class DownloadFile {
    
    
    public void download(String url, String name) {
    
    
        try {
    
    
            FileUtils.copyURLToFile(new URL(url), new File(name));
        } catch (IOException e) {
    
    
            e.printStackTrace();
            System.out.println("IO异常");
        }
    }
}

** 多线程可以应用到JavaWeb注册功能，如：前端发起注册请求，后台在处理时一般会往邮箱发送注册信息的邮件，此时如果一直等待发送邮件后才响应前端可能会出现超时情况或响应时间过长导致用户体验度极差从而流失客户，所以可以利用多线程在接收到注册请求后，在数据库登记完用户信息后，重新起一个线程去给用户发送邮件，然后就可以给前端响应了，这样就可以大大的提高效率，优化用户体验。

2 实现方法二： 实现Runnable接口

2.1 实现Runnable接口，并用其初始化Thread，然后创建Thread实例，并调用start方法

public class Race implements Runnable {
    
    

    // 胜利者
    private static String winner;

    @Override
    public void run() {
    
    
        for (int i = 0; i <=100 ; i++) {
    
    
            // 设置让兔子睡觉（休眠）
            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 + "步");
        }
    }

    // 判断是否完成比赛
    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;
    }

    public static void main(String[] args) {
    
    
        Race race = new Race();
        new Thread(race, "兔子").start();
        new Thread(race, "乌龟").start();
    }
}

以上代码是观看“狂神”老师的视频练习的demo。

3 实现方法三：实现Callable接口

3.1 实现Callable接口，并用其初始化Thread，然后创建Thread实例，并调用start方法

public class Thread3 {
    
    
    public static void main(String[] args) {
    
    

        for(int i=0;i<2;i++) {
    
    
            //创建MyThread实例
            Callable<String> call = new MyThread();
            //获取FutureTask
            FutureTask<String> ft = new FutureTask<String>(call);
            //使用FutureTask初始化Thread
            Thread t = new Thread(ft);
            //输出：
            //Thread-0 Thread-1
            t.start();
        }
    }
}

class MyThread implements Callable<String> {
    
    

    @Override
    public String call() throws Exception {
    
    
        System.out.println(Thread.currentThread().getName());
        return "success";
    }
}

4 实现方法四：线程池

4.1 使用线程池创建

public class Thread4 {
    
    
    public static void main(String[] args) {
    
    

        ExecutorService executorService = Executors.newFixedThreadPool(5);
        for(int i=0;i<9;i++) {
    
    
            executorService.execute(new MyThread1());
            FutureTask<String> ft = new FutureTask<String>(new MyThread2());
            executorService.submit(ft);
        }
        executorService.shutdown();
    }
}

class MyThread1 implements Runnable {
    
    

    @Override
    public void run() {
    
    
        System.out.println("Runnable"+ Thread.currentThread().getName());
    }
}

class MyThread2 implements Callable<String> {
    
    

    @Override
    public String call() throws Exception {
    
    
        System.out.println("Callable"+ Thread.currentThread().getName());
        return "success";
    }
}