1.多线程的创建和启动方式
- 1.线程第一种启动方式（继承Thread类）
- 2.多线程的第二种启动方式实现Runnable接口
- 3.多线程的第三种启动方式实现Callable接口
2.Thread多线程中的方法
- 1.getName(), setName(),currentThread(),sleep
- 2.Thread优先级调度方法
- 3.守护线程
- 4.出让线程/礼让线程
- 5.插入线程/插队线程

多线程涵盖的基本概念：链接: 程序进程和线程（线程的并发与并行）

1.多线程的创建和启动方式

在这里插入图片描述

1.线程第一种启动方式（继承Thread类）

//Thread第一种启动方式
//1.定义一个类继承Thread类
//2.重写run方法
//3.创建子类的对象，并启动线程

package threadDemo01;


public class test01 {
    //Thread第一种启动方式
    //1.定义一个类继承Thread类
    //2.重写run方法
    //3.创建子类的对象，并启动线程
    public static void main(String[] args) {
        myThread t1=new myThread();
        myThread t2=new myThread();
        t1.setName("线程1");
        t2.setName("线程2");
        t1.start();//启动线程
        t2.start();//启动线程
    }
}

package threadDemo01;

/**
 * @version 1.0
 * @auther Demo龙
 */
public class myThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(getName()+"jhsgdf");
        }
    }
}

在这里插入图片描述

2.多线程的第二种启动方式实现Runnable接口

/*
* 多线程的第二种启动方式Runnable
* 1.定义一个类继承Runnable接口
* 2.重写run方法
* 3.创建子类的对象
* 4.创建一个Thread类的对象，并开启线程
* */

package threadDemo02;

/**
 * @version 1.0
 * @auther Demo龙
 */
public class test02 {
    public static void main(String[] args) {
        /*
        * 多线程的第二种启动方式Runnable
        * 1.定义一个类继承Runnable接口
        * 2.重写run方法
        * 3.创建子类的对象
        * 4.创建一个Thread类的对象，并开启线程
        * */
        //1.创建myRunnable对象
        myRunnable r1 = new myRunnable();
        myRunnable r2 = new myRunnable();

        //2.创建线程对象
        Thread t1=new Thread(r1);
        Thread t2=new Thread(r2);
        t1.setName("线程1");
        t2.setName("线程2");
        t1.start();//启动线程
        t2.start();//启动线程

    }
}

package threadDemo02;

/**
 * @version 1.0
 * @auther Demo龙
 */
public class myRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            Thread t=Thread.currentThread();
            System.out.println(t.getName()+"ksjdhg");
        }
    }
}

在这里插入图片描述

3.多线程的第三种启动方式实现Callable接口

多线程的第三种启动方式：
* 特点：可以获取到多线程运行的结果。
* 1.创建一个类myCallable实现Callable接口
* 2.重写call方法（有返回值）
* 3.创建myCallable对象（表示多线程要执行的任务）
* 4.创建FutureTask对象（作用：管理多线程运行的结果）
* 5.创建Thread类的对象并启动。（表示线程）

package threadDemo03;

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

/**
 * @version 1.0
 * @auther Demo龙
 */
public class test03 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        /*
        * 多线程的第三种启动方式：
        *      特点：可以获取到多线程运行的结果。
        * 1.创建一个类myCallable实现Callable接口
        * 2.重写call方法（有返回值）
        * 3.创建myCallable对象（表示多线程要执行的任务）
        * 4.创建FutureTask对象（作用：管理多线程运行的结果）
        * 5.创建Thread类的对象并启动。（表示线程）
        * */
        //3.创建myCallable对象（表示多线程要执行的任务）
        myCallable mc = new myCallable();
        //4.创建FutureTask对象（作用：管理多线程运行的结果）
        FutureTask <Integer>ft = new FutureTask<>(mc);
        //5.创建Thread类的对象并启动。（表示线程）
        Thread t1=new Thread(ft);
        t1.start();

        //6.获取多线程运行的结果
        Integer result=ft.get();
        System.out.println("result="+result);

    }
}

package threadDemo03;

import java.util.concurrent.Callable;

/**
 * @version 1.0
 * @auther Demo龙
 */
public class myCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int sum=0;
        for (int i = 0; i < 20; i++) {
            sum+=i;
        }
        return sum;
    }
}

在这里插入图片描述

2.Thread多线程中的方法

1.getName(), setName(),currentThread(),sleep

getName()Theard 类中得到线程名字的方法

setName设置线程的name（如果没有给线程设置名字，默认为Thread-X（从0开始））

static Thread currentThread().返回当前线程的对象
/*细节
* 1.当JVM机启动之后，会自动启动多条线程
* 其中有一条就叫做main线程
* 它的作用就是调用main方法，并执行里面的代码
* 以前我们所写的代码，其实就是运行在main线程当中。
* */

static void sleep(long time)让线程指定休眠时间，单位为毫秒
/*细节
* 1.哪条线程执行到这个方法，那么哪条线程就会在这里停留对应时间
* 2.方法参数：ms，
* 3.时间到了以后，线程继续执行下面的其他代码
* */

package threadMethod01;
/**
 * @version 1.0
 * @auther Demo龙
 */
public class test01 {
    /*
    *
    * */
    public static void main(String[] args) throws InterruptedException {
        //创建线程对象
        myThread t1=new myThread();
        myThread t2=new myThread();
        //1.setName设置线程的name（
        //      如果没有给线程设置名字，默认为Thread-X（从0开始））
        t1.setName("线程1");
        t2.setName("线程2");
        t1.start();//启动线程
        t2.start();//启动线程

        //3.static Thread currentThread().返回当前线程的对象
            /*细节
            * 1.当JVM机启动之后，会自动启动多条线程
            *   其中有一条就叫做main线程
            *   它的作用就是调用main方法，并执行里面的代码
            * 以前我们所写的代码，其实就是运行在main线程当中。
            * */
        Thread t = Thread.currentThread();
        System.out.println("t="+t);
        System.out.println("t.getName()="+t.getName());//main

        //4.static void sleep(long time)让线程指定休眠时间，单位为毫秒
            /*细节
            * 1.哪条线程执行到这个方法，那么哪条线程就会在这里停留对应时间
            * 2.方法参数：ms，
            * 3.时间到了以后，线程继续执行下面的其他代码
            * */
        Thread.sleep(5000);//休眠5秒
        System.out.println("8888888888888888888888");

    }
}

package threadMethod01;

/**
 * @version 1.0
 * @auther Demo龙
 */
public class myThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            //2.getName()Theard 类中得到线程名字的方法
            System.out.println(getName()+"@"+i);
        }
    }
}

在这里插入图片描述

2.Thread优先级调度方法

/*抢占式调度（）随机
* 1.setPriority(int newPriority) 设置线程的优先级
* 2.getPriority() 获取线程的优先级
* */

package threadMethod02;

/**
 * @version 1.0
 * @auther Demo龙
 */
public class test02 {
    /*抢占式调度（）随机
    *   1.setPriority(int newPriority)  设置线程的优先级（1-10）
    *   2.getPriority()  获取线程的优先级
    * */
    public static void main(String[] args) throws InterruptedException {
        //创建线程要执行的参数对象
        myThread02 r=new myThread02();

        //创建线程对象
        Thread t1=new Thread(r,"坦克");
        Thread t2=new Thread(r,"飞机");
        //查看默认优先级=5
        System.out.println(t1.getPriority());//5
        System.out.println(t2.getPriority());//5
        System.out.println(Thread.currentThread().getPriority());//5
        //设置默认优先级
        t1.setPriority(10);//优先级最高
        t2.setPriority(1);//优先级最低
        t1.start();
        t2.start();

    }
}

package threadMethod02;

/**
 * @version 1.0
 * @auther Demo龙
 */
public class myThread02 implements Runnable{

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

在这里插入图片描述

3.守护线程

/*
* final void setDaemon(boolean on) 设置为守护线程
* 细节：当其他的非守护线程执行完毕后，守护线程会陆续结束(不是立即)。
* */

package threadMethod03;

/**
 * @version 1.0
 * @auther Demo龙
 */
public class test03 {
    public static void main(String[] args) throws InterruptedException {
        /*
        * final void setDaemon(boolean on) 设置为守护线程
        *     细节：当其他的非守护线程执行完毕后，守护线程会陆续结束(不是立即)。
        * */
        //创建线程对象
        myThread1 t1=new myThread1("飞机");
        myThread2 t2=new myThread2("坦克");

        //设置为守护线程
        t2.setDaemon(true);//（设置t2为备胎，其他非备胎结束了，t2也慢慢（时间不一）会结束）
        
        t1.start();
        t2.start();
    }
}

package threadMethod03;

/**
 * @version 1.0
 * @auther Demo龙
 */
public class myThread1 extends Thread{

    public myThread1() {
    }

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

    @Override
    public void run() {

        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"@"+i);
        }
    }
}

package threadMethod03;

/**
 * @version 1.0
 * @auther Demo龙
 */
public class myThread2 extends Thread{
    public myThread2() {
    }

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

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

4.出让线程/礼让线程

/*
*public static void yield();出让线程/礼让线程
* */
//表示出让（礼让）当前CPU的执行权
//尽可能让结果均匀
Thread.yield();

package threadMethod04;

/**
 * @version 1.0
 * @auther Demo龙
 */
public class test {
    /*
    *public static void yield();出让线程/礼让线程
    * */
    public static void main(String[] args) throws InterruptedException {
        //创建线程对象
        myThread t1=new myThread();
        myThread t2=new myThread();
        t1.setName("线程1");
        t2.setName("线程2");

        t1.start();//启动线程
        t2.start();//启动线程

    }
}

package threadMethod04;

/**
 * @version 1.0
 * @auther Demo龙
 */
public class myThread extends Thread{


    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {

            System.out.println(getName()+"@"+i);
            //表示出让（礼让）当前CPU的执行权
            //尽可能让结果均匀
            Thread.yield();
        }
    }
}

5.插入线程/插队线程

/*
*public static void join();插入线程/插队线程
t1.join();//表示把t1这个线程插入到当前线程之前
//当前线程：正在运行的线程

* */

package threadMethod05;
/**
 * @version 1.0
 * @auther Demo龙
 */
public class test {
    /*
    *public static void join();插入线程/插队线程
    * */
    public static void main(String[] args) throws InterruptedException {
        //创建线程对象
        myThread t1=new myThread();
        t1.setName("恐龙");
        t1.start();//启动线程

        t1.join();//表示把t1这个线程插入到当前线程之前
        //当前线程：正在运行的线程

        for (int i = 0; i < 20; i++) {
            System.out.println("main线程"+i);
        }

    }
}

package threadMethod05;

/**
 * @version 1.0
 * @auther Demo龙
 */
public class myThread extends Thread{


    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {

            System.out.println(getName()+"@"+i);

        }
    }
}