一篇文章带你理解Thread(多线程)的基础用法

目录

1.线程创建

1.1通过继承类创建

1.2通过类实现接口创建

1.3通过内部类继承Thread来创建

1.4通过内部类实现Runnable接口来创建

1.5通过lambda表达式创建

2.线程中断

2.1自定义标志位

2.2interrupt()方法

3.线程等待

4.线程休眠

5.获取线程实例

---

1.线程创建

        线程创建有五种方法,这里喜欢用那种用那种

注意:下文中的start方法才是多线程开始执行,run方法只是表明需要执行的内容

1.1通过继承类创建

class A extends Thread {
    @Override
    public void run() {
        System.out.println("通过继承Thread类创建线程");
    }
}



public class Main {
    public static void main(String[] args) {
        A a = new A();
        //这里的start是线程开始执行的方法,执行的是Thread中的run方法
        a.start();
    }
}

这里需要注意,当我们继承Thread类的时候,必须重新run方法,相当于是在给线程分配任务

1.2通过类实现接口创建

class B implements Runnable{
    @Override
    public void run() {
        System.out.println("通过实现Runnable接口来创建");
    }
}


public class Main {
    public static void main(String[] args) {

        //这里通过Thread类型对象,对构造方法传入一个实现了Runnable接口的类来创建
        Thread b = new Thread(new B());
        b.start();
    }
}

1.3通过内部类继承Thread来创建

public class Main {
    public static void main(String[] args) {
     

        Thread c = new Thread(){
            @Override
            public void run() {
                System.out.println("通过匿名内部类继承Thread来创建");
            }
        };
        c.start();
    }
}

1.4通过内部类实现Runnable接口来创建

public class Main {
    public static void main(String[] args) {
    
        Thread d = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("通过匿名内部类实现Runnable接口来实现");
            }
        });
        d.start();

        
    }
}

1.5通过lambda表达式创建

public class Main {
    public static void main(String[] args) {
 

        Thread e = new Thread(()-> System.out.println("使用lambda表达式创建"));
        e.start();



    }
}

最后我们看一下所有的执行结果

总结:

可以发现,只有通过继承Thread类的时候,不需要创建Thread对象,其余的都需要创建Thread对象

2.线程中断

2.1自定义标志位

这种方法很简单,就是自己定义一个变量,用来标识线程结束,当执行某条语句,则线程结束,就不进行演示了

2.2interrupt()方法

不仅可以用自定义的标志位,我们还可以调用interrupt方法,来进行线程中断

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            //通过Thread.interrupted()判断是否存在标志位,若不存在则一直执行while,若存在则停止并且清除标志位
           while(!Thread.interrupted()){
               System.out.println("123");
           }
        });
        t1.start();
        Thread.sleep(1);
//通过t1.interrupt()创建标志位
        t1.interrupt();
    }
}

上述代码中的含义是,开始没标志位,所以while语句可以一直执行,当我们执行到t1.interrupt之后,创建了一个标志位,这样我们就拥有了标志位,所以while循环就会终止,代码的运行结果如下

可以看到我们的线程是有停止的

 我们总结一些常用的标志位用法

1.Thread.interrupt()       设置标志位,若线程阻塞则抛出异常,并且清除标志位

2.Thread.interrupted()     判断是否有标志位,若存在返回true,否则返回false,最后清除标志位 

3.Thread..currentThread().isInterrputed()      判断是否有标志位,若存在返回true,否则返回false,最后不清除标志位 

第三个个currentThread是得到当前线程的引用,通过这个引用再去调用isInterrputed方法

 

可以看到,isInterrupted方法是线程实例中的方法,不是类方法,所以我们需要通过引用来调用

3.线程等待

在多线程中,一个线程等待另一个线程,通常使用jion()方法

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println("别急,我还没结束呢");
            }
            System.out.println("我结束了");
        });
        t1.start();
        t1.join();
        System.out.println("你终于结束了");
    }
}

看这段代码,就是让主线程去等待t1线程,就是通过调用t1的join()方法来实现的,看一下运行结果

可以看到,当我们的主线程走到t1.join()之后,进行了阻塞等待,然后等t1执行结束了,才开始执行主线程后面的内容,这就是线程的等待

4.线程休眠

线程休眠我们通常使用sleep方法,这个方法是存在于Thread中的类方法,需要传入一个参数,单位是毫秒,就是让当前线程阻塞等待多长时间之后,再执行,看具体实现

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                System.out.println("别急,我还没结束呢");
            }
            System.out.println("我结束了");
        });
        t1.start();

        Thread.sleep(1);
        System.out.println("============================================================");
    }
}

看这样一段代码,我们让主线程一秒后打印一串'=',当我们运行线程的时候

可以看到,主线程等待一秒后,打印了=,但是t1并未执行结束,但是我们的主线程调用的是sleep方法,所以并不会无限制的等下去

注意:这里的sleep需要处理编译异常,

InterruptedException

 

我们可以像上面一样加上声明,也可以使用try{}catch来处理,这个我们在异常的时候已经说过了,就不再赘述了

 

5.获取线程实例

这里我们使用currentThread来获取线程的实例,这里和this有异曲同工之妙,在哪里调用的,就会获取到哪个实例,看代码实现

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            System.out.println(Thread.currentThread());
        });
        t1.start();
        System.out.println(Thread.currentThread());
       
    }
}

运行结果是这样的

我们可以看到,在main中的是main线程,t1是Thread-0线程,我们做个测试,如果,在主线程中通过t1来调用currentThread获取到的是哪个线程呢?

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            
        });
        t1.start();
        
       
        System.out.println(t1.currentThread());
    }
}

 我们可以看到,我们在主线程中通过t1去调用currentThread()方法,得到结果也是和我们预期的一样

为什么?

因为我们的currentThread()是一个静态方法,所以不论你通过什么Thread的实例调用,其实结果都是一样的,只有一个,就是当前线程的引用 

以上就是多线程的一些基本使用了

        感谢阅读