2022年06月26日报告

下面是关于多线程的内容 同学们

1.创建线程的方式

①第一种: 

继承 Thread类 重写run方法 使用start()方法开启线程

public class Test1 extends Thread {
    // 重写 run方法,run()方法里写的就是线程里要执行的东西
    @Override
    public void run() {
        for (int i = 0; i <= 80; i++) {
            // 继承 Thread类以后,通过 getName()方法可以获取当前线程的名称
            System.out.println("线程名称" + this.getName() + "\t" + i);
        }
    }

    public static void main(String[] args) {
            // 这里的 main是一个主线程
        for (int i = 0; i < 80; i++) {
            // 调用 Thread类的 currentThread方法返回当前线程对象
            System.out.println("线程名称:" + Thread.currentThread().getName() + "\t" + i);
            if (i == 10) {
            // 这里开启的两个是子线程
                new Test1().start();
                new Test1().start();
            }
        }
    }
}

②第二种: 

实现Runnable接口,重写run()方法

import java.io.*;

public class Task1 implements Runnable{
    // 实现Runnable接口的类是个任务,不是线程
    // 下面是完成了一个对文件的打印操作
    private File scrFile;
    private File desFile;

    public Task1(File scrFile,File desFile){
        this.scrFile=scrFile;
        this.desFile=desFile;
    }
        // run()方法里面是线程要完成的任务 
    @Override
    public void run() {
    try {
        // 拷贝一个文件
        InputStream input=new FileInputStream(this.scrFile);
        OutputStream output=new FileOutputStream(this.desFile);
        byte[] bytes=new byte[1024];
        int size;
        while ((size=input.read())>0){
            output.write(bytes,0,size);
        }
        input.close();
        output.close();
    }catch (Exception e){
            e.printStackTrace();
    }
        System.out.println("拷贝完成,拷贝由:"+Thread.currentThread().getName()+"来完成");
    }
}

public class Test1 {
    public static void main(String[] args) {
        File scrFile=new File("C:\\Users\\llp\\Downloads\\战地5.jpeg");
        File desFile=new File("./file\\战地5.jpeg");
        // 该方法创建线程时,要先创建实现类的对象
        Task1 task1=new Task1(scrFile,desFile);
        // 然后创建一个线程对象,把实现类对象传过去
        Thread thread=new Thread(task1);
        thread.start();
    }
}

③实现Callable接口

import java.io.*;
import java.util.concurrent.Callable;

public class CallTask implements Callable<Long> {
    // 实现Callable 接口
    // 这也是完成一个文件拷贝操作
    private File srcFile=null;
    private File desFile=null;
    private long time=0;

    public CallTask(File srcFile,File desFile){
        this.srcFile=srcFile;
        this.desFile=desFile;
    }
    public long getTime() {
        return time;
    }

    public void setTime(long time) {
        this.time = time;
    }

    // 重写 call()方法 里面就是要执行的任务
    @Override
    public Long call() throws Exception {
        try {
            InputStream input=new FileInputStream(srcFile);
            OutputStream output=new FileOutputStream(desFile);
            byte[] bytes=new byte[1024];
            int size;
            long start=System.currentTimeMillis();
            while ((size=input.read())>0){
                output.write(bytes,0,size);
            }
            input.close();
            output.close();
            long end=System.currentTimeMillis();
            this.time=end-start;
            Thread.sleep(3000);
        }catch (Exception e){
            e.printStackTrace();
        }
    return this.time;
    }
}

import java.io.File;
import java.util.concurrent.*;

public class Test {
    public static void main(String[] args) throws Exception{
        // 创建线程在另一个类里创建
        // 这里就是要拷贝的文件
        File srcFile=new File("C:\\Users\\llp\\Downloads\\战地5.jpeg");
        // 这是要拷贝到哪里去
        File desFile=new File("./file\\战地5.jpeg");

        // 1.创建一个 Callable对象 里面放一个实现类对象
        Callable<Long> call=new CallTask(srcFile,desFile);
        // 2.创建一个FutureTask对象, 把这个 Callable对象交给它
        FutureTask<Long> task=new FutureTask<>(call);
        // 3.再创建一个 Thread对象把 FutureTask对象交给它
        Thread thread=new Thread(task);
        // 4.最后利用thread.start()开启线程

        thread.start();
        long time=task.get(10, TimeUnit.SECONDS);
        System.out.println("共耗时"+time+"毫秒");
    }
}