实现线程操作的三种方法

以你之姓@ 2023-08-17 16:02 100阅读 0赞

#### 1-1 进程 ####

*  程序是静止的，运行中的程序就是进程。
 *  进程的三个特征：
    
     *  **动态性** ： 进程是运行中的程序，要动态的占用内存，CPU和网络等资源。
     *  **独立性** ： 进程与进程之间是相关独立的，彼此有自己的独立内存区域。
     *  **并发性** ： 假如CPU是单核，同一个时刻其实内存中只有一个进程在被执行。 CPU会分时轮询切换依次为每个进程服务，因为切换的速度非快，给我们的感觉这些进程在==同时执行，这就是并发性。==
     *  **并行**：同一个时刻同时在执行。

#### 1-2 线程 ####

*  线程是属于进程的。==一个进程可以包含多个线程，这就是多线程==。线程创建开销相对于进程来说比较小。 线程也支持并发性。
 *  线程的作用: 可以提高程序的效率，可以有更多机会得到CPU。

#### 1-3 进程和线程的总结 ####

*  进程是运行中的程序。有动态性，独立性，并发性。一个进程可以包含多个线程，线程也支持并发。
 *  多线程可以提高程序的整体效率，可以解决很多业务需求。因为多个线程是并发抢占CPU执行，所以多线程的执行会出现随机性。

#### 2-创建线程的三种方式 ####

**方式1**：定义一个线程类继承Thread类，然后重写run()方法，再创建线程对象，调用start()方法启动线程

/**
    方式一的步骤：
     a.定义一个线程类继承Thread类
     b.重写Thread类的run()方法
     c.创建一个子线程对象
     d.调用线程对象的start()方法启动线程（其实最终就是执行线程对象的run()方法）
    
     线程的注意：
     1.启动线程不能直接调用run()方法，否则是普通对象的普通方法调用了，将失去线程特征。线程的启动必须调用start()
     2.一般是先创建子线程，再申明主线程的任务，否则主线程任务总是先执行完！
    
     优缺点：
       优点：编码简单。
       缺点：线程类已经继承了Thread类，不能再继承其他类，功能被削弱了。不能做线程池。无法直接返回线程执行的结果。
     */
    public class ThreadDemo {
        // 自带一个线程：main方法本身就是一个线程，是最牛逼的线程！
        public static void main(String[] args) {
            //  c.创建一个子线程对象
            MyThread t = new MyThread();
            //  d.启动线程
            // 注意：启动线程不能直接调用run()方法，否则是普通对象的普通方法调用了，将失去线程特征。
            // 线程的启动必须调用start()
            t.start();
    
            for(int i = 0 ;  i < 10; i++){
                System.out.println("main线程执行："+i);
            }
        }
    }
    
    // 线程类不是线程对象，是用来创建线程对象的。
    //  a.定义一个线程类继承Thread类
    class MyThread extends Thread{
        //  b.重写Thread类的run()方法
        @Override
        public void run() {
            for(int i = 0 ;  i < 10; i++){
                System.out.println("子线程执行："+i);
            }
        }
    }

**方式2**：定义一个线程任务类实现Runnable接口，然后重写run()方法。创建线程任务对象，把线程任务对象包装成线程对象，调用start()方法启动线程

/**
    a.定义一个线程任务类实现Runnable接口。重写run()方法
    b.创建一个线程任务对象
    c.把线程任务对象包装成一个线程对象
        -- public Thread(Runnable target)
    d.调用线程对象的start()方法启动线程。
    
    优缺点：
        缺点：编程相对复杂，不能直接返回线程的执行结果
        优点：
             1. 一个任务对象可以被反复包装成多个线程对象。
             2. 可以避免java中的单继承的局限性。因为线程任务对象只是实现了接口，还可以继续继承其他类和实现其他接口。
             3. 实现解耦操作，线程任务对象代码可以被多个线程共享，代码和线程独立。
             4. 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。适合做线程池。
     */
    public class ThreadDemo {
        public static void main(String[] args) {
            // b.创建一个线程任务对象
            Runnable target = new MyRunnable();
            // c.把线程任务对象包装成线程对象
            Thread t = new Thread(target);
            // d.调用线程对象的start()方法启动线程。
            t.start();
    
            Thread t1 = new Thread(target);
            t1.start();
    
            for(int i = 0 ;  i < 10; i++){
                System.out.println(Thread.currentThread().getName()+"=>"+i);
            }
        }
    
    }
    // 线程任务类
    //   a.定义一个线程任务类实现Runnable接口。
    class MyRunnable implements Runnable{
        @Override
        public void run() {
            for(int i = 0 ;  i < 10; i++){
                System.out.println(Thread.currentThread().getName()+"=>"+i);
            }
        }
    }

**方式三**：定义一个线程任务类实现Callable接口

/**
    a.定义一个线程任务类实现Callable接口。
    b.重写call()方法。
    c.把线程任务对象包装成一个未来任务对象。
    d.把未来任务对象包装成一个线程对象。
    e.调用线程对象的start()方法启动线程。
    优缺点：
        缺点：编码复杂。
        优点：全是优点。
            可以继续继承其他类。
            可以做线程池。
            可以得到线程返回的结果。
            可以做资源共享操作
    
     */
    public class ThreadDemo {
        public static void main(String[] args) {
            MyCallable call = new MyCallable();
            // c.把线程任务对象包装成一个未来任务对象。
            /**
             * 未来任务对象： FutureTask
             *  1.可以通过未来任务对象去获取线程执行的结果。
             *  2.未来任务对象其实就是一个Runnable的对象。
             */
            FutureTask<String> target = new FutureTask<>(call);
            //  d.把未来任务对象包装成一个线程对象。
            Thread t = new Thread(target);
            //  e.调用线程对象的start()方法启动线程。
            t.start();
    
            for(int i = 0 ;  i < 10; i++){
                System.out.println(Thread.currentThread().getName()+"=>"+i);
            }
    
            try {
                // 线程的执行的结果！
                String result = target.get();
                System.out.println(result);
            }  catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    //  a.定义一个线程任务类实现Callable接口。申明返回值类型
    class MyCallable implements Callable<String>{
        //  b.重写call()方法。
        @Override
        public String call() throws Exception {
            int count = 0 ;
            for(int i = 0 ;  i < 10; i++){
                count+=(i+1) ; // 1-10的和。
                System.out.println(Thread.currentThread().getName()+"=>"+i);
            }
            return Thread.currentThread().getName()+"求和结果："+count;
        }
    }

转载于:https://www.cnblogs.com/Guard9/p/11152841.html