[Java知识库]多线程学习

? 多线程的创建方式有三种

实现方式一继承Thread类

首先创建线程类 继承Thread

public class MyThread extends Thread{//继承Thread

    //重写run方法 方法里面是我们要做的事情
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("子线程运行:"+i);
        }
    }
}

创建测试类 并在主线程下启动子线程 调用

myThread.start();方法

代码

public class ThreadDemo {
    public static void main(String[] args) {
        //创建线程对象
        MyThread myThread = new MyThread();
        //启动子线程
        myThread.start();

        //主线程需要做的事情
        for (int i = 0; i < 10; i++) {
            System.out.println("主线程:"+i);
        }
/* 结果  子线程和主线程在同运行 有先有后 不一定是谁先谁后
主线程:0
主线程:1
子线程运行:0
主线程:2
子线程运行:1
子线程运行:2
子线程运行:3
子线程运行:4
主线程:3
子线程运行:5
子线程运行:6
子线程运行:7
子线程运行:8
子线程运行:9
主线程:4
主线程:5
主线程:6
主线程:7
主线程:8
主线程:9

Process finished with exit code 0

 */
    }
}

?实现方式二 实现Runnable接口

?创建任务类 实现Runnable接口

/**
 实现方式二 实现Runnable接口
 */
public class MyRunnable implements Runnable{

    //创建任务
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("子线程运行:"+i);
        }
    }
}

?创建测试类

public class RunnableDemo {
    public static void main(String[] args) {
        //创建任务对象 不是创建线程对象
        MyRunnable myRunnable = new MyRunnable();

        //把任务转换成线程
        Thread thread = new Thread(myRunnable);
        thread.start();

        for (int i = 0; i < 10; i++) {
            System.out.println("主线程运行:"+i);
        }
    }
}

匿名内部类写法?

方式一?

/*
匿名内部类写法
 */
public class RunnableDemo {
    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 200; i++) {
                    System.out.println("内部类 子线程:"+i);
                }
            }
        };
        //启动线程
        new Thread(runnable).start();


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

因为Runnable接口是函数式接口 只有一个抽象方法

所有就可以用lambda表达式来简化写法

方式二

public class RunnableDemo02 {
    /*
    匿名内部类可以用lambda表达式简化
     */
    public static void main(String[] args) {
        Runnable runnable =()-> {
            for (int i = 0; i < 100; i++) {
                System.out.println("lambda表达式"+i);
            }
        };

        //任务对象转换成多线程启动类对象
        new Thread(runnable).start();

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

最简化版

public class RunnableDemo03 {
    /*
    最终简化
     */
    public static void main(String[] args) {

        new Thread(()-> {
            for (int i = 0; i < 100; i++) {
                System.out.println("最终简化实现"+i);
            }
        }).start();//启动线程

        //主线程类
        for (int i = 0; i < 100; i++) {
            System.out.println("主线程"+i);
        }
    }
}

创建方式三

创建任务对象

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        return "牛逼";
    }
}

?测试

public class CallableDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyCallable myCallable = new MyCallable();

        //把他封装成任务对象 FutureTask 是实现Runnable接口的 所有用它来封装Callable接口
        //用他来得到返回结果
        FutureTask<String> stringFutureTask = new FutureTask<String>(myCallable);

        //封装成线程对象
        new Thread(stringFutureTask).start();

        //拿到结果对象
        System.out.println(stringFutureTask.get());
    }
}

?总结

?Thread常用API

给多个线程取名字

设定线程任务

public class MyThread extends Thread{
    public MyThread() {
    }

    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName()+i);//currentThread().getName() 得到当前线程名字
        }
    }
}

方式一 通过setName方法设定名字

public class ThreadDemo {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyThread());
        thread.setName("1号线程");
        thread.start();

        Thread thread2 = new Thread(new MyThread());
        thread2.setName("2号线程");
        thread2.start();


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

?方式二通过构造器来取名字

public class ThreadDemo01 {
    public static void main(String[] args) {
        //通过构造器注入名字
        new MyThread("一号线程").start();
        new MyThread("二号线程").start();
        new MyThread("三号线程").start();

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

线程的休眠方法 sleep

? 代码

public class ThreadDemo02 extends Thread{
    @SneakyThrows//异常注解
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(i);
            if (i==4){
                Thread.sleep(3000);//休息三秒
            }
        }
    }

    public static void main(String[] args) {

        ThreadDemo02 threadDemo02 = new ThreadDemo02();
        threadDemo02.start();

    }
}

总结