【java】【高级拓展5】多线程-优快云博客

package com.runa;

/**
 * 1让子类继承Thread类
 */
public class MyThread extends Thread{
    //2必须重新Thread的run方法
    @Override
    public void run() {
        // 3描述线程的执行任务
        for (int i = 0; i <= 5 ; i++) {
            System.out.println("子线程MyThread线程输出：" + i);

        }

    }
}

3.1.2 主函数

package com.runa;

/**
 * 目标： 掌握线程的创建方式1：继承Thread
 */
public class ThreadTest1 {

    //main 由一条默认的主线程负责执行的
    public static void main(String[] args) {
        //  4创建MyThread线程类的对象代表一个线程
        Thread t = new MyThread();
        // 5   启动线程
        t.start();

        for (int i = 0; i <= 5 ; i++) {
            System.out.println("主线程输出：" + i);

        }

    }
}

3.2 方式二：实现Runnable接口

3.2.1 定义一个任务类MyRunnable

package com.runa;

/**
 * 1 定义一个任务类实现Runnable接口
 */
public class MyRunnable implements Runnable{
    // 2 重写runnable的run 方法
    @Override
    public void run() {
        //  线程要执行的任务
        for (int i = 0; i <= 5; i++) {
            System.out.println("子线程的输出===" + i);
        }

    }
}

3.2.2 主函数

package com.runa;

public class ThreadTest2 {
    public static void main(String[] args) {
    // 3 创建任务对象
        Runnable target = new MyRunnable();
      // 把任务对象交给一个线程对象处理
        new Thread(target).start();

        for (int i = 0; i <= 5; i++) {
            System.out.println("主线程输出====" + i);
        }
    }
}

3.2.3 方式二的匿名内部类的写法

package com.runa;

public class ThreadTest2_2 {
    public static void main(String[] args) {
    // 1 直接创建Runnable匿名内部类形式（任务对象）
        Runnable target = new MyRunnable() {
            @Override
            public void run(){
                //  线程要执行的任务
                for (int i = 0; i <= 5; i++) {
                    System.out.println("子线程的输出===" + i);
                }
            }
        };

        new Thread(target).start();


        for (int i = 0; i <= 5; i++) {
            System.out.println("主线程输出====" + i);
        }
    }
}

简化代码

package com.runa;

public class ThreadTest2_3 {
    public static void main(String[] args) {
    // 1 直接创建Runnable匿名内部类形式（任务对象）


        new Thread(new MyRunnable() {
            @Override
            public void run(){
                //  线程要执行的任务
                for (int i = 0; i <= 5; i++) {
                    System.out.println("子线程的输出===" + i);
                }
            }
        }).start();


        for (int i = 0; i <= 5; i++) {
            System.out.println("主线程输出====" + i);
        }
    }
}

再简化

package com.runa;

public class ThreadTest2_4 {
    public static void main(String[] args) {
    // 1 直接创建Runnable匿名内部类形式（任务对象）


        new Thread(() ->  {for (int i = 0; i <= 5; i++) {
                    System.out.println("子线程的输出===" + i);
                }
            }).start();


        for (int i = 0; i <= 5; i++) {
            System.out.println("主线程输出====" + i);
        }
    }
}

3.3 方式三：实现Callable接口

3.3.1 定义一个类实现MyCallable接口

package com.runa;

import java.util.concurrent.Callable;

/**
 * 1 让这个类实现Callable接口
 */
public class MyCallable implements Callable<String> {
    private int n;

    public MyCallable(int n) {
        this.n = n;
    }

    // 重写这个call方法
    @Override
    public String call() throws Exception {
        // 描述线程的任务，返回线程执行返回后的结果
        // 需求 求1-n的和返回
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += i;

        }
        return "线程求出了1 -" + n + "的和是：" + sum;
    }
}

3.3.2 主函数

package com.runa;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

public class ThreadTest3 {
    public static void main(String[] args) throws Exception {
        // 3 创建一个Callable的对象
        Callable<String> call = new MyCallable(100);
        // 4 把 Callable的对象封装成一个FutureTask对象（任务对象）
        // 未来任务对象的作用 1、实现了Runnable对象 2、 可以在线程执行完毕之后，用未来任务对象调用get方法获取线程执行完毕后的结构
        FutureTask<String> f1 = new FutureTask<>(call);
        // 5把任务对象交给一个Thread对象
        new Thread(f1).start();


        // 再来一份
        Callable<String> call2 = new MyCallable(200);
        FutureTask<String> f2 = new FutureTask<>(call2);
        new Thread(f2).start();

       //获取线程执行完毕后返回的结果
        //注意如果执行到这儿，上面的线程还没有执行完毕，这里的代码会暂停，等待上面线程执行完毕后才会获取结果
        String rs = f1.get();
        System.out.println(rs);

        String rs2 = f2.get();
        System.out.println(rs2);
    }
}

4 Thread的常用方法

4.1 子线程MyThread

package com.runa;

public class MyThread extends Thread{
    // 有参构造器
    public MyThread(String name) {
        super(name);// 为当前线程设置名字
    }

    // 无参构造器
    public MyThread() {
    }

    @Override
    public void run() {
        // 哪个线程执行他，他就会得到哪个线程对象
        Thread t = Thread.currentThread();
        for (int i = 0; i <= 5 ; i++) {
            System.out.println(t.getName() + "输出" + i);

        }

    }
}

4.2 主线程

package com.runa;

public class ThreadTest4 {
    public static void main(String[] args) throws Exception {
        Thread t1 = new MyThread();
        t1.setName("t1线程");
        t1.start();
        System.out.println(t1.getName());


        Thread t2 = new MyThread("t2线程");
//        t2.setName("t2线程");
        t2.start();
        System.out.println(t2.getName());

        // 主线程对象的命中
        Thread m = Thread.currentThread();
        m.setName("最牛的主线程");
        System.out.println(m.getName());
        for (int i = 0; i <= 5; i++) {
            System.out.println(m.getName() + "线程输出：" + i);
            if(i == 3){
                //会让当前执行的线程暂停5秒，再继续
                Thread.sleep(5000);
            }


        }

        // join 方法作用，让当前调用的这个方法的线程先执行完

        Thread t3 = new MyThread("t3线程");
        t3.start();
        t3.join();

        Thread t4 = new MyThread("t4线程");
        t4.start();
        t4.join();

    }
}