码迷，mamicode.com
首页 > 编程语言 > 详细

29、多线程（线程池、定时器）、将一个文件复制多次、拆分文件并合并、多线程复制文件

时间：2020-06-07 19:08:55      阅读：65      评论：0      收藏：0      [点我收藏+]

标签：private   抽象   music   close   rcfile   rgs   pointer   应该   end   

目录

线程池

程序启动一个新线程成本是比较高的，因为它涉及到与操作系统交互。而使用线程池可以很好的提高性能，尤其是

当程序中要创建大量生存期很短的线程时，更应该考虑使用线程池。

线程池里的每一个线程代码结束后，并不会死亡，而是再次回到线程池中成为空闲状态，等待下一个对象来使用。

在JDK 5之前，我们必须手动实现自己的线程池，从JDK 5开始，Java内置支持线程池。

package org.westos.demo;

import java.util.concurrent.*;

/**
 * @author lwj
 * @date 2020/6/7 8:36
 */
public class MyTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        /*
        线程池：容器，存有一定数量线程对象的容器
        JDK5新增了一个Executors工厂类来产生线程池，有如下几个方法
		public static ExecutorService newCachedThreadPool():			根据任务的数量来创建线程对应的线程个数
		public static ExecutorService newFixedThreadPool(int nThreads):	固定初始化几个线程
		public static ExecutorService newSingleThreadExecutor():			初始化一个线程的线程池
        这些方法的返回值是ExecutorService对象，该对象表示一个线程池，可以执行Runnable对象或者Callable对象代表的线程。它提供了如下方法
            Future<?> submit(Runnable task)
            <T> Future<T> submit(Callable<T> task)
        使用步骤：
            创建线程池对象
            创建Runnable实例
            提交Runnable实例
            关闭线程池
         */
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程执行了这个任务");
            }
        });
        //根据任务数量创建相应数量的线程对象
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println("提交第二个任务");
            }
        });
        Future<Integer> submit = executorService.submit(new MyCallable());
        System.out.println(submit.get());

        executorService.shutdown();
        //关闭线程池
    }
}

class MyCallable implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        return 100;
    }
}

package org.westos.demo2;

import java.util.concurrent.*;

/**
 * @author lwj
 * @date 2020/6/7 8:36
 */
public class MyTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        /*
        线程池：容器，存有一定数量线程对象的容器
        JDK5新增了一个Executors工厂类来产生线程池，有如下几个方法
		public static ExecutorService newCachedThreadPool():			根据任务的数量来创建线程对应的线程个数
		public static ExecutorService newFixedThreadPool(int nThreads):	固定初始化几个线程
		public static ExecutorService newSingleThreadExecutor():			初始化一个线程的线程池
        这些方法的返回值是ExecutorService对象，该对象表示一个线程池，可以执行Runnable对象或者Callable对象代表的线程。它提供了如下方法
            Future<?> submit(Runnable task)
            <T> Future<T> submit(Callable<T> task)
        使用步骤：
            创建线程池对象
            创建Runnable实例
            提交Runnable实例
            关闭线程池
         */
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        });
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        });
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        });
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        });

        executorService.shutdown();
    }
}

package org.westos.demo3;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author lwj
 * @date 2020/6/7 8:36
 */
public class MyTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        /*
        线程池：容器，存有一定数量线程对象的容器
        JDK5新增了一个Executors工厂类来产生线程池，有如下几个方法
		public static ExecutorService newCachedThreadPool():			根据任务的数量来创建线程对应的线程个数
		public static ExecutorService newFixedThreadPool(int nThreads):	固定初始化几个线程
		public static ExecutorService newSingleThreadExecutor():			初始化一个线程的线程池
        这些方法的返回值是ExecutorService对象，该对象表示一个线程池，可以执行Runnable对象或者Callable对象代表的线程。它提供了如下方法
            Future<?> submit(Runnable task)
            <T> Future<T> submit(Callable<T> task)
        使用步骤：
            创建线程池对象
            创建Runnable实例
            提交Runnable实例
            关闭线程池
         */
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        });
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        });

        executorService.shutdown();
    }
}

定时器与定时任务

package org.westos.demo4;

import java.util.Timer;
import java.util.TimerTask;

/**
 * 定时器
 * @author lwj
 * @date 2020/6/7 9:28
 */
public class MyTest {
    public static void main(String[] args) {
        Timer timer = new Timer();
        //TimerTask抽象类
        MyTimerTask myTimerTask = new MyTimerTask(timer);
        timer.schedule(myTimerTask, 3000);
        //等3s后执行该定时任务

        // 取消定时器
        // timer.cancel();
    }
}

class MyTimerTask extends TimerTask {
    public Timer timer;

    public MyTimerTask(Timer timer) {
        this.timer = timer;
    }

    @Override
    public void run() {
        System.out.println("时间到了");
        timer.cancel();
    }
}

package org.westos.demo4;

import java.util.Timer;
import java.util.TimerTask;

/**
 * @author lwj
 * @date 2020/6/7 9:36
 */
public class MyTest2 {
    public static void main(String[] args) {
        Timer timer = new Timer();
        MyTimerTask2 myTimerTask2 = new MyTimerTask2();
        timer.schedule(myTimerTask2, 3000, 1000);
        //等3s后执行此任务，以后间隔1s重复执行定时任务
    }
}

class MyTimerTask2 extends TimerTask {

    @Override
    public void run() {
        System.out.println("时间到了");
    }
}

package org.westos.demo4;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

/**
 * @author lwj
 * @date 2020/6/7 9:38
 */
public class MyTest3 {
    public static void main(String[] args) throws ParseException {
        Timer timer = new Timer();
        MyTimerTask3 myTimerTask3 = new MyTimerTask3();
        //myTimerTask2.cancel(); 取消定时任务

        String str = "2020-06-07 09:49:00";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date parse = sdf.parse(str);

        timer.schedule(myTimerTask3, parse);
        //指定某个时间执行定时任务
    }
}

class MyTimerTask3 extends TimerTask {

    @Override
    public void run() {
        System.out.println("时间到了");
    }
}

指定时间删除文件夹

package org.westos.demo4;

import java.io.File;
import java.util.Timer;
import java.util.TimerTask;

/**
 * 定时删除一个文件夹
 * @author lwj
 * @date 2020/6/7 9:49
 */
public class MyDemo {
    public static void main(String[] args) {
        Timer timer = new Timer();
        //定时器

        File source = new File("E:\\新建文件夹");
        TimerTaskDemo timerTaskDemo = new TimerTaskDemo(source, timer);

        timer.schedule(timerTaskDemo, 5000);
        //延迟5s后执行定时任务，删除文件夹
    }
}

class TimerTaskDemo extends TimerTask {
    public File directory;
    public Timer timer;

    public TimerTaskDemo(File directory, Timer timer) {
        this.directory = directory;
        this.timer = timer;
    }

    @Override
    public void run() {
        //删除文件夹并关闭定时器
        deleteDir(directory);
        timer.cancel();
        //取消定时器
    }

    public void deleteDir(File file) {
        if (file.isDirectory()) {
            File[] files = file.listFiles();
            for (File file1 : files) {
                deleteDir(file1);
            }
        }
        file.delete();
        //删除文件或者空文件夹
    }
}

练习题

1、把一个文件复制多次

package org.westos.demo5;

import java.io.*;

/**
 * @author lwj
 * @date 2020/6/7 15:11
 */
public class MyTest {
    public static void main(String[] args) throws IOException {
        File source = new File("C:\\Users\\shawn\\Music\\MV\\G.E.M. 邓紫棋-我说了算（多芬秀发合作单曲）(蓝光).mp4");
        RandomAccessFile rw = new RandomAccessFile(source, "rw");
        byte[] bytes = new byte[1024 * 8];
        int len = 0;
        for (int i = 0; i < 3; i++) {
            FileOutputStream fos = new FileOutputStream(new File("E:\\music", "G.E.M" + i + ".mp4"));
            while ((len = rw.read(bytes)) != -1) {
                fos.write(bytes, 0, len);
                fos.flush();
            }
            fos.close();
            //每复制一个文件，将随机读取流的指针重置为0
            rw.seek(0);
        }
        rw.close();
    }
}

2、拆分文件并合并

package org.westos.demo5;

import java.io.*;
import java.util.Arrays;
import java.util.Enumeration;
import java.util.Vector;

/**
 * @author lwj
 * @date 2020/6/7 15:24
 */
public class MyTest2 {
    public static void main(String[] args) throws IOException {
        split();
        merge();
    }

    private static void merge() throws IOException {
        File source = new File(".");
        System.out.println(source.getAbsolutePath());
        File[] files = source.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                return pathname.isFile() && pathname.length() <= 1024 * 1024 && pathname.getName().endsWith(".mp3");
            }
        });
        Vector<FileInputStream> vector = new Vector<>();
        for (File file : files) {
            vector.addElement(new FileInputStream(file));
        }
        Enumeration<FileInputStream> elements = vector.elements();
        SequenceInputStream sis = new SequenceInputStream(elements);

        byte[] bytes = new byte[1024];
        int len = 0;
        FileOutputStream fos = new FileOutputStream(new File("百事.mp3"));
        while ((len = sis.read(bytes)) != -1) {
            fos.write(bytes, 0, len);
            fos.flush();
        }
        fos.close();
        sis.close();
    }

    private static void split() throws IOException {
        //把一份文件拆分为多份，每份1M，然后合并
        File source = new File("C:\\Users\\shawn\\Music\\G.E.M. 邓紫棋 _ 王嘉尔 - 热爱就一起.mp3");

        FileInputStream fis = new FileInputStream(source);
        byte[] bytes = new byte[1024 * 1024];
        int len = 0;
        int index = 0;
        while ((len = fis.read(bytes)) != -1) {
            FileOutputStream fos = new FileOutputStream(new File(index++ + ".mp3"));
            fos.write(bytes, 0, len);
            fos.close();
        }
        fis.close();
    }
}

3、多线程复制文件

package org.westos.demo5;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;

/**
 * @author lwj
 * @date 2020/6/7 15:49
 */
public class MyDemo {
    public static void main(String[] args) throws FileNotFoundException {
        //多线程复制同一份文件
        File source = new File("C:\\Users\\shawn\\Music\\G.E.M. 邓紫棋 _ 王嘉尔 - 热爱就一起.mp3");
        File destFile = new File(".\\邓紫棋-热爱就一起.mp3");
        long length = source.length();
        //文件的总大小
        long threadNums = 3;
        long average = length / threadNums;
        for (int i = 0; i < 3; i++) {
            long start = i * (average + 1);
            long end = (i + 1) * average;
            new CopyFileThread(start, end, source, destFile).start();
        }
        //如果3个线程不能均分，那么再添加一个线程
        if (length % threadNums != 0) {
            long start = threadNums * average + 1;
            new CopyFileThread(start, length, source, destFile).start();
        }
    }
}


class CopyFileThread extends Thread {
    public long start;
    public long end;
    public RandomAccessFile in;
    public RandomAccessFile out;

    public CopyFileThread(long start, long end, File srcFile, File destFile) throws FileNotFoundException {
        this.start = start;
        this.end = end;
        this.in = new RandomAccessFile(srcFile, "rw");
        this.out = new RandomAccessFile(destFile, "rw");
    }

    @Override
    public void run() {
        try {
            in.seek(start);
            out.seek(start);
            //设置读写起始指针
            byte[] bytes = new byte[1024 * 8];
            int len = 0;
            long pointer = in.getFilePointer();
            while (pointer <= end && (len = in.read(bytes)) != -1) {
                //最后一次有可能只剩余1KB,然而最后一次还是会读取8KB,然后pointer > end退出while
                out.write(bytes, 0, len);
                pointer += len;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

29、多线程（线程池、定时器）、将一个文件复制多次、拆分文件并合并、多线程复制文件

标签：private   抽象   music   close   rcfile   rgs   pointer   应该   end   

原文地址：https://www.cnblogs.com/shawnyue-08/p/13061505.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！