java多线程

package threadcase1;

public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+"hello world");
        }
    }
}

测试类

package threadcase1;

public class ThreadDemo {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        t1.setName("线程1");
        t2.setName("线程2");
        t1.start();
        t2.start();
    }
}

可以看到两个线程交替进行

多线程的第二种实现方式实现Runnable接口的方式进行实现

先写MyRun类

package threadcase2;

public class MyRun implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 50; i++) {
            //获取当前线程对象
            Thread t = Thread.currentThread();
            System.out.println(t.getName()+"hello world");
        }
    }
}

测试类

package threadcase2;

public class ThreadDemo {
    public static void main(String[] args) {
        //创建MyRun对象
        MyRun mr = new MyRun();
        //创建线程对象
        Thread t1 = new Thread(mr);
        Thread t2 = new Thread(mr);
        //给线程设置名字
        t1.setName("线程1");
        t2.setName("线程2");
        //开启线程
        t1.start();
        t2.start();
    }
}

利用Callable接口和Future接口方式实现

创建一个类MyCallable实现callable接口重写call(是有返回值的，表示多线程运行的结果)

创建MyCallable的对象(表示多线程要执行的任务)

创建FutureTask的对象(作用管理多线程运行的结果)

创建Thread类的对象，并启动(表示线程)

MyCallable类

package threadcase3;

import java.util.concurrent.Callable;

public class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int sum=0;
        for (int i = 0; i <= 100; i++) {
                sum=sum+i;
        }
        return sum;
    }
}

测试类

package threadcase3;

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

public class ThreadDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建MyCallable的对象(表示多线程要执行的任务)
        MyCallable mc = new MyCallable();
        //创建FutureTask的对象(作用管理多线程运行的结果)
        FutureTask ft = new FutureTask<>(mc);
        //创建Thread类的对象，并启动(表示线程)
        Thread t1 = new Thread(ft);
        //启动线程
        t1.start();
        //获取多线程运行的结果
        Object result = ft.get();
        System.out.println(result);
    }
}

继承Thread类优点：编程比较简单，可以直接使用Thread类中的方法
缺点：可以扩展性较差，不能再继承其他的类

实现Runnable接口优点：扩展性强实现该接口的同时还可以继承其他的类

缺点：编程相对复杂，不能直接使用Thread类中的方法

实现Callable接口优点：扩展性强实现该接口的同时还可以继承其他的类

缺点：编程相对复杂，不能直接使用Thread类中的方法

想要获取多线程运行的结果就用Callable接口的方法

多线程中常用的成员方法

String getName()                返回此线程的名称
void setName(String name)                设置线程的名字(构造方法也可以设置名字)
static Thread currentThread()                获取当前线程的对象

static void sleep(long time)                让线程休眠指定的时间，单位为毫秒

setPriority(int newPriority)        设置线程的优先级

final int getPriority() 获取线程的优先级
final void setDaemon(boolean on)                设置为守护线程
public static void yield()                出让线程/礼让线程
public static void join()        插入线程/插队线程

String getName() 返回此线程的名称

如果我们没有给线程设置名字，线程也是有默认的名字的格式:Thread-x(X序号，从0开始的)

void setName(String name) 设置线程的名字(构造方法也可以设置名字)

如果我们要给线程设置名字，可以用set方法进行设置，也可以构造方法设置

static Thread currentThread() 获取当前线程的对象

package Threadmethod;

public class ThreadDemo {
    public static void main(String[] args) {
       
        Thread t = Thread.currentThread();
        String name = t.getName();
        System.out.println(name);
    }
}

当JVM虚拟机启动之后，会自动的启动多条线程其中有一条线程就叫做main线程他的作用就是去调用main方法，并执行里面的代码

static void sleep(long time) 让线程休眠指定的时间，单位为毫秒

package Threadmethod;

public class ThreadDemo {
    public static void main(String[] args) throws InterruptedException {

        System.out.println("111111");
        Thread.sleep(3000);
        System.out.println("222222");
    }
}

哪条线程执行到这个方法，那么哪条线程就会在这里停留对应的时间

方法的参数:就表示睡眠的时间，单位毫秒

当时间到了之后，线程会自动的醒来，继续执行下面的其他代码