2023/7/4

多线程

 

单线程程序：从头往下依次运行

多线程程序：可以在多个程序中切换，将等待的时间充分利用起来，提高程序效率

总结：

并发和并行

 

多线程的实现方式：

Thread实现多线程的第一种方式

package treadclass1;

public class TreadDemo {
    public static void main(String[] args) {
        /*
    多线程的第一种启动方式：
    1.自己定义一个类继承Tread
    2.重写run方法
    3.创建子类对象，并启动线程
     */

        MyTread t1=new MyTread();
        MyTread t2=new MyTread();

        //为线程取名
        t1.setName("线程1");
        t2.setName("线程2");

        //开启线程
        t1.start();
        t2.start();
    }
}



package treadclass1;

public class MyTread extends Thread{
    public void run(){
        //书写线程要执行的代码
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+"HelloWorld");
        }
    }
}

第二种方式：使用Runnable接口来实现

package threadclass2;

   public class Threadadaemo2 {
       public static void main(String[] args) {
            /*
                 多线程的第二种启动方式
                  1.自己定义一个类实现Runnable接口
                  2.重写里面的run方法
                  3.创建自己的类的对象
                  4.创建一个Thread类的对象，并开启线程
            */
           //创建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();
       }
  }


package threadclass2;

public class MyRun implements Runnable{
    @Override
    public void run() {
        //书写线程要执行的代码
        for (int i = 0; i < 100; i++) {
            //获取到当前线程的对象
            Thread t=Thread.currentThread();
            System.out.println(t.getName()+"HelloWorld");
        }
    }
}

 第三种方式：有返回值、利用Callable接口实现

package threadclass3;

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

public class ThreadDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        /*
    多线程的第三种实现方式
    特点：可以获取到多线程运行的结果
    1.创建一个类MyCallable实现Callable接口
    2.重写call（是有返回值的，表示多线程的运行结果）
    3.创建MyCallable的对象（表示多线程要执行的任务）
    4.创建FutureTask的对象（作用管理多线程运行的结果）
    5.创建Thread类的对象，并启动（表示线程）
     */

        //创建MyCallable的对象（表示多线程要执行的任务）
        MyCallable mc=new MyCallable();
        //创建FutureTask的对象（作用管理多线程运行的结果）
        FutureTask<Integer> ft=new FutureTask<>(mc);
        //创建线程对象
        Thread t1=new Thread(ft);
        //启动线程
        t1.start();

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

package threadclass3;

import java.util.concurrent.Callable;

public class MyCallable implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        //求1-100的和
        int sum=0;
        for (int i = 0; i < 100; i++) {
            sum=sum+i;
        }

        return sum;
    }
}

 总结：

 常见的成员方法