多线程(java)

class MyThread1 extends Thread{
    @Override
    public void run() {
        while(true){
            System.out.println("main");
        }
    }
}

public class ThreadDemo1 {

    public static void main(String[] args) {
        MyThread1 thread = new MyThread1();
        thread.start();
        while(true){
            System.out.println("main");
        }
    }
}

2.实现Runnable,重写run

class MyThread implements Runnable{
    @Override
    public void run() {
        while(true){
            System.out.println("thread");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}
public class ThreadDemo1{
    public static void main(String[] args) throws InterruptedException {
        //实现Runnable的实例
        MyThread2 myThread = new MyThread2();
        //将Runnable的实例作为参数
        Thread thread = new Thread(myThread2);
        thread.start();
        while(true){
            System.out.println("main");
            Thread.sleep(1000);
        }
    }
}

3.继承Thread,匿名内部类

public class ThreadDemo3 {
    public static void main(String[] args) {
        Thread thread = new Thread(){
            @Override
            public void run() {
                while(true){
                    System.out.println("thread");
                }
            }
        };
        thread.start();
        
        while(true){
            System.out.println("main");
        }
    }

}

4.实现Runnable,匿名内部类

public class ThreadDemo4 {
    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                while(true){
                    System.out.println("thread");
                }
            }
        });
        thread.start();
        
        while (true){
            System.out.println("main");
        }
    }
}

5.lambda表达式

也是最常用的一个

public class ThreadDemo5 {
    public static void main(String[] args) {
        Thread thread = new Thread(() ->{
            while(true){
                System.out.println("thread");
            }
        });
        thread.start();

        while(true){
            System.out.println("main");
        }
    }
}

6.Callable

Callable的用法非常类似于Runnable,描述一个线程要干啥

Runnable通过run方法描述,返回值为void,

Callable通过call方法描述,返回值为一个泛型;

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

//Callable
public class ThreadDemo6 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<Integer> callable = new Callable<Integer>() {
            int sum = 0;
            //计算1+2+3.......+1000
            @Override
            public Integer call() throws Exception {
                for(int i = 0; i <= 1000; i++){
                    sum += i;
                }
                return sum;
            }
        };
        //进行打包
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        Thread thread = new Thread(futureTask);
        thread.start();
        //得到返回值
        System.out.println(futureTask.get());
    }
}

Thread不能直接传Callable,需要用FutureTask进行包装;

FutureTask的get方法在Thread的线程没有进行完时会进行阻塞等待

三 Thread

方法

isDaemon():

true表示是后台线程 false表示是前台线程

前台线程会阻止java进程结束必须得java进程中所有的前台线程都执行完java进程才能结束;

创建的线程默认是前台的;

可以通过setDaemon设置成后台

常见构造方法

常用属性

start方法: 真正从系统这里,创建一个线程,新的线程将会执行run方法.

run方法: 表示了线程的入口方法是啥(线程启动起来,要执行哪些逻辑)

中断线程(isInterrupted)

public class ThreadDemo7 {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            //currentThread是获取当前线程实例
            //isInterrupted就是thread对象里自带的一个标志位
            while(!Thread.currentThread().isInterrupted()){
                System.out.println("thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        thread.start();

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        thread.interrupt();

    }
}

interrupt方法的作用:

1.设置标志位为true

2.如果该线程正在阻塞(比如执行sleep),此时就会把阻塞状态唤醒;通过抛出异常的方式让sleep立即结束

注意:当sleep被唤醒的时候,sleep会自动把isInterrupted标志位给清空(true -> false)

等待一个线程(join)

public class ThreadDemo8 {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            System.out.println("thread");
        });
        thread.start();
        thread.join();

        System.out.println("main");
    }
}

main线程运行到join时会陷入阻塞,等待thread执行完

thread.join()会等到thread执行完

thread.join(time)在time内等待