java——多线程—启动线程

不念不忘少年蓝@ 2021-12-09 00:21 351阅读 0赞

继承Thread启动线程

package com.mycom.继承Thread启动线程;
    
    /**
     *
     * 继承Thread类启动线程的步骤
     * 1.定义自定义线程类并继承Thread
     * 2.重写run方法
     * 3.创建自定义线程对象并调用start()方法
     *
     * 注意：
     *    启动完多线程以后所有的线程会争夺CPU的执行权，哪个线程拿到了执行权哪个线程就会执行代码
     */
    public class MyThread extends Thread {
        /**
         * 线程的主体方法，这个方法中应该编写线程需要具体执行的程序代码任务
         * 这个方法不能手动调用，当我们调用当前类对象的start方法以后JVM会自动执行这个run启动一个线程
         */
        public void run() {
           for(;;){
               System.out.println("-----------------------------------------------------");
           }
        }
    }

测试：

package com.mycom.继承Thread启动线程;
    
    /**
     * Author: gay
     */
    public class RunMain {
        public static void main(String[] args) {
            //创建自定义线程对象
            MyThread t1=new MyThread();
            t1.start();//启动线程
    //        t1.run();
            for(;;){
                System.out.println("==================================================");
            }
        }
    }

实现Runable接口启动线程

package com.mycom.实现Runnabl接口启动线程;
    
    /**
     * 实现Runnable接口启动线程的步骤
     * 1.定义自定义线程类
     * 2.实现Runnable并实现接口中的run方法
     * 3.由于Runnable接口中没有start方法因此必须要借助Thread类启动多线程
     */
    public class MyThread implements Runnable {
    
        public void run() {
            for(;;){
                System.out.println("-------------------------------------------------------");
            }
        }
    }

测试：

package com.mycom.实现Runnabl接口启动线程;
    
    /**
     * Author: gay
     */
    public class RunMain {
        public static void main(String[] args) {
            MyThread t1=new MyThread();
            Thread thread=new Thread(t1);//根据一个Runnalbe的子类对象创建一个线程对象
            thread.start();//借助Thread类中的start方法启动线程
    
            //使用匿名内部类启动线程
            new Thread(new Runnable() {
                public void run() {
                    for(;;){
                        System.out.println("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
                    }
    
                }
            }).start();
            //使用lambda表达式启动线程
            new Thread(()->{
                for(;;){
                    System.out.println("***********************************************************");
                }
            }).start();
    
            for(;;){
                System.out.println("===========================================");
            }
        }
    }

实现Callable接口启动线程

package com.mycom.使用Callable接口启动线程;
    
    import java.util.concurrent.Callable;
    
    /**
     * 实现Callable可以实现多线程的并发计算
     * 在大数据量计算时推荐使用这样的方式来实现
     */
    public class MyThread implements Callable<Integer> {
    
        private int startNum;
        private int stopNum;
    
        public MyThread(int startNum, int stopNum) {
            this.startNum = startNum;
            this.stopNum = stopNum;
        }
    
        public MyThread() {
        }
    
        /*
                    并发计算的方法 这个方法将返回计算的结果
                */
        public Integer call() throws Exception {
            int sum=0;
            for(int i=startNum;i<=stopNum;i++){
                sum+=i;
            }
            return sum;
        }
    }

测试：

package com.mycom.使用Callable接口启动线程;
    
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.FutureTask;
    
    /**
     * Author: gay
     */
    public class RunMain {
        public static void main(String[] args) {
    
    
            try {
                MyThread myThread=new MyThread(1,50);
                FutureTask<Integer> ft=new FutureTask<Integer> (myThread);
                Thread thread=new Thread(ft);
                thread.start();
                System.out.println(ft.get());
    
                MyThread myThread2=new MyThread(51,100);
                FutureTask<Integer> ft2=new FutureTask<Integer> (myThread2);
                Thread thread2=new Thread(ft2);
                thread2.start();
                System.out.println(ft.get()+ft2.get());
    
    
    
    
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
    }

每个线程都有自己的线程栈

转载于:https://www.cnblogs.com/Tpf386/p/11178556.html