多线程

一、多线程是什么

二、如何在程序中创建多个线程

1.线程的创建方式1（继承Thread类）

1.代码：

public class Mythread extends Thread{
    //1.必须继承Thread类
    //2.必须重写Thread的run（）方法

    @Override
    public void run() {
        //描述线程的执行任务
        for (int i = 0; i <=5; i++){
            System.out.println ("MyThread输出"+i);
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {//main()方法由一条默认的主线程执行的
        //3.创建线程类的对象来代表一个线程
        Thread t=new Mythread ();
        //4.启动线程
        t.start ();// mian线程   t线程   自定执行run方法
        for (int i=0;i<=5;i++){
            System.out.println ("主线程main输出"+i);
        }
    }
}

2.注意事项

2.线程的创建方式2（实现Runable接口）

 1.代码

        //1.实现Runable接口

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        //2.重写run方法
        //线程要执行的任务
        for (int i=0;i<=5;i++){
            System.out.println ("子线程输出===="+i);
        }
    }
}


public class Test1 {
    public static void main(String[] args) {
        //3.创建任务对象
        Runnable target=new MyRunnable ();
        //4.把任务对象交给一个Thread对象处理
        new Thread (target).start ();//实现线程

        for (int i = 0; i < 6; i++) {
            System.out.println ("主线程输出"+i);
        }
    }
}

2.优缺点

3.匿名内部类写法

public class Test2 {
    public static void main(String[] args) {
        //1.直接创建Runnable接口的匿名内部类形式（任务对象）
        Runnable target =new Runnable () {
            @Override
            public void run() {
                for (int i = 0; i <6; i++) {
                    System.out.println ("匿名内部类"+i);
                }
            }
        };
        new Thread (target).start ();
        new Thread ( new Runnable () {
            @Override
            public void run() {
                for (int i = 0; i <6; i++) {
                    System.out.println ("匿名内部类2:"+i);
            }
        }; }).start ();

        new Thread (  ()-> {

                for (int i = 0; i <6; i++) {
                    System.out.println ("匿名内部类3:"+i);
                }
             }).start ();


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

3.线程的创建方式3（实现Callable接口、FutureTask类来实现）

1.优点

2.实现步骤

3.代码

import java.util.concurrent.Callable;

/**
 * 1.实现Callable接口
 */
public class MyCallable implements Callable {//线程执行完之后返回的类型
    private int n;

    public MyCallable(int n) {
        this.n = n;
    }

    //2.重写Call方法
    @Override
    public String call() throws Exception {
        //描述线程执行的任务，返回线程执行完成后的结果
        //需求：求1-n的和 返回
        int sum=0;
        for (int i = 1; i  call =new MyCallable ( 100 );
        //4.把Callable的对象封装成一个FutureTask对象（任务对象）
        /**
         * 作用：1.FutureTask是一个任务对象，实现了Runnable接口
         *      2.可以在线程执行完毕之后，用未来任务对象调用get方法获取线程执行完毕后的结果
         */
        FutureTask f1 = new FutureTask<> ( call );
        //5.把任务对象交给一个Thread对象
        new Thread (f1).start ();
        //6.获取线程执行完毕后返回的结果
        Callable call1 =new MyCallable ( 200 );
        FutureTask f2 = new FutureTask<> ( call1 );
        new Thread (f2).start ();
        //5.把任务对象交给一个Thread对象
        new Thread (f1).start ();
        String rs = f1.get ();
        System.out.println ( rs );
        String rs2 = f2.get ();
        System.out.println ( rs2 );
    }
}

三、线程的常用方法

1.常用API

2.代码

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

    /**
     * 有参构造
     */
    public MyThread(String name){
        super(name);//把名字送到父类有参构造器
    }
    @Override
    public void run() {
        Thread t = Thread.currentThread ();
        String name = t.getName ();

        for (int i = 0; i <=3 ; i++) {
            System.out.println ("子线程输出"+name+":"+i);
        }

    }

}


public class Test4 {
    public static void main(String[] args) {
        Thread t1=new MyThread ();
        t1.setName ( "1号线程" );//为线程设置名字（在线程启动之前）
        t1.start ();
        System.out.println ( t1.getName () );
        Thread t2=new MyThread ();
        t2.setName ( "2号线程" );
        t2.start ();
        System.out.println ( t2.getName () );
        Thread t3 = new MyThread ( "3号线程" );//有参构造
        t3.start ();
        //主线程对象的名字
        //哪个线程执行它，它就会的到哪个线程对象
        Thread m = Thread.currentThread ();
        m.setName ( "最牛的线程" );
        String name = m.getName ();
        System.out.println ( m.getName () );
        for (int i = 0; i <=5; i++) {
            System.out.println (name+"："+i);

        }
    }
}


public class Test5 {
    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i <=5; i++) {
            System.out.println (i);
            //休眠5s
            if (i==3){
                //让当前执行的线程暂停5s后再执行
                Thread.sleep ( 5000 );
            }
        }
        //join方法的作用：让当前调用这个方法的线程先执行完
        Thread t1 = new MyThread ( "1号线程" );
        t1.start ();
        t1.join ();
        Thread t2 = new MyThread ( "2号线程" );
        t2.start ();
        t2.join ();
        Thread t3 = new MyThread ( "3号线程" );
        t3.start ();
        t3.join ();

    }
}