Java多线程实践2-Thread类与Runable接口

目录

1.线程与任务？

2.Thread类

3.实现多线程的两种形式对比

4.lambda表达式简介

 5.线程休眠--调用sleep()方法
​​​​​​​

1.线程与任务？

线程是用来执行任务，与任务进行绑定，脱离了任务的线程没有意义。线程通过Thread线程创建，任务通过Runable来定义的。

实现线程的两种方法：1.继承Thread类。2.实现Runable接口（无返回值，开发中推荐此方式，解耦合）。3.实现Callable接口（有返回值）。

2.Thread类

Thread构造器：无参构造不需要指定任务（一般不用），有参构造可以直接指定线程的任务（target）。

图2-1 无参构造

 图2-2 有参构造

流程：

1，创建线程对象。

2，启动线程（调用start()方法）---》就绪状态。

3，一旦拿到CPU资源，开始执行任务，调用Thread的run()方法，target参数为任务。

图2-3 Thread类里面的run()方法 

图2-4 Thread类中的target成员变量（该变量用于接受创建线程对象时传入的任务） 

3.实现多线程的两种形式对比

1.继承，缺点：直接将任务的实现写到了线程类当中（任务直接写到类里面），耦合度太高，无法让一个线程做多个任务。下面是用该方式实现的多线程：

package org.example.threads;

public class ThreadTest1 extends Thread{
    public static void main(String[] args){
        //1.创建线程对象
        Thread thread1=createAThread(10);
        //2.启动线程
        thread1.start();

    }
    public static Thread createAThread(int num){
        Thread thread=new Thread(()->{
            for (int i=0;i<num;i++){
                System.out.println(i+"");
            }
        });
        return thread;
    }
    //重写run方法，线程对象一旦争夺到CPU资源，就会调用自己的run方法。
    @Override
    public void run() {
        super.run();
    }
}

2.使用实现接口的方式可以解决上述问题。下面是用该方式实现的示例代码：

package org.example.threads;

public class Runnable1 implements Runnable{


    @Override
    public void run() {
        for (int i=0;i<10;i++){
            System.out.println(i+"");
        }
    }

}

public class Test {
    public static void main(String[] args){
        //1.创建一个任务（Runnable1里面定义任务）
        Runnable runnable1=new Runnable1();
        //2.创建一个线程
        Thread thread=new Thread(runnable1);
        //3.线程启动
        thread.start();
    }
}

4.lambda表达式简介

lambda函数式编程：可以将方法的具体实现作为参数进行传值。

实现接口形式的缺点：1.使用匿名内部类的形式来减少内部类的定义。

例：

 2.使用lambda表达式进一步简化代码，只把方法的实现进行传值，而不需要关注其他的内容。

 

 5.线程休眠--调用sleep()方法

跟调用者无关。写到哪个线程里面，就是让哪个线程休眠。

public class Test2 {
    public static void main(String[] args){
        Thread thread1=new Thread(()->{
            for (int i=0;i<10;i++){
                System.out.println(1);
            }
        });
        thread1.start();


        Thread thread2=new Thread(

                ()->{
                    try {
                        thread1.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    for (int i=0;i<10;i++){
                    System.out.println(2);
            }
        });
        thread2.start();
    }
}

上面代码运行结果：

示例2：

public class Test2 {
    public static void main(String[] args){
        Thread thread1=new Thread(()->{
            for (int i=0;i<10;i++){
                System.out.println(1);
            }
        });
        thread1.start();


        Thread thread2=new Thread(

                ()->{
                    for (int i=0;i<10;i++){
                    System.out.println(2);
                        try {
                            thread1.sleep(1000);
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
            }
        });
        thread2.start();
    }
}

示例二运行结果：