java多线程

多线程实现方式

继承Thread类

流程

1.定义一个类继承Thread，

2.重写run方法

3.创建对象，调用start方法；开启线程

代码

继承Thread类，重写run方法
public class MyThread extends Thread{
    public static void main(String[] args) {

    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(getName()+"hello,world");
        }
    }
}
创建线程，调用start对象创建线程

public class Main {
    public static void main(String[] args) {
        MyThread t1=new MyThread();
        MyThread t2=new MyThread();
        MyThread t3=new MyThread();
        t1.setName("线程一");
        t2.setName("线程二");
        t3.setName("线程三");
        t1.start();;
        t3.start();
        t2.start();
    }
}

 实现Runnable接口

流程

1.实现Runnable接口

2.重写run方法

3.创建自己的类

4.创建Thread类，传递自己的类；

5.启动run方法

代码

public class MyThread1 implements  Runnable{
    @Override
    public void run() {
        for (int i = 0; i <10 ; i++) {
            Thread t=Thread.currentThread();
            System.out.println(t.getName()+"mike");
        }
    }
}
 Thread t7=new Thread(t6);

        Thread t5=new Thread(t4);

        t5.setName("线程5");
        t7.setName("线程7");

        t5.start();
        t7.start();

利用Callable接口和Future接口实现

Callable和FutureTask可以返回线程的结果，并对线程进行管理；

Callable可以返回结果，FutureTask可以对线程进行管理,

流程

流程：创建Callable对象->Callable对象作为FutureTask对象的构造参数，创造FutureTask对象，->将FutureTask对象作为参数创建Thread对象->Thread对象调用start启动线程->FutureTask对象调用get方法返回线程的结果值；

代码

public class MyCallable implements Callable {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //可以返回现成的结果；
        MyCallable ms=new MyCallable();

        //利用futuretask管理线程；
        FutureTaskft=new FutureTask<>(ms);

        Thread t=new Thread(ft);

        t.start();
        Integer res=ft.get();
        System.out.println(res);
    }
    @Override
    public Integer call() throws Exception {
        int sum=0;
        for (int i = 0; i < 10; i++) {
            sum+=i;
        }
        return sum;
    }//表示返回结果的类型


}

三种方式的不同

前两种无法返回线程的结果，第三种可以，推荐第三种。

Thread类的方法

常见成员方法

sleep方法：将会让当前线程休眠，在main方法里就是main线程

Thread.currentThread:获取当前线程的对象；

  public static void main(String[] args) throws InterruptedException {
        //将获取当前线程对象；
        Thread t=Thread.currentThread();
        Thread.sleep(5000);
        System.out.println(t.getName());
    }

setpriority(int newpriority)

设置当前线程的优先级，默认为5，最高10，最低1

int getpriority()

返回当前线程的优先级

void setDaemon(boolean on);设置守护线程

守护线程的生命周期与非守护线程 一样，非守护线程结束，守护线程也会结束；

yield()

当前线程将会让出CPU的执行权，但下一次仍然会抢夺；

join()

将线程插入到当前线程之前，只有线程执行完后，当前线程才会执行；

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

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

    public static void main(String[] args) throws InterruptedException {
        MyThread5 t=new MyThread5("女神");
      //  t.setPriority(9);
        MyThread3 t1=new MyThread3("备胎");
      //  t1.setPriority(6);
        t1.setDaemon(true);
        t1.start();
        t.start();
        t.join();
     int i=   Thread.currentThread().getPriority();
        System.out.println(i);
        for (int j = 0; j <11 ; j++) {
            System.out.println(j);
        }
    }

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

线程的状态

锁

synchronized是一个bool量，表示两种状态，一个线程获得锁后，量的值改变，其余线程都无法获得。

LOCK锁