精华内容
下载资源
问答
  • json(pickle)用法记录

    2017-07-28 17:19:16
    将内存数据放入文件保存: 从文件中将数据读到内存
    将内存数据放入文件中保存:
    从文件中将数据读到内存:
    展开全文
  • 1、RDB: 快照形式,在指定的时间间隔内将内存中数据集写入磁盘中,保存到dump.rdb的二进制文件中,数据需要恢复时磁盘中将快照文件直接读到内存中 redis.conf文件中配置,如图: 900秒内修改一次则save一次;...

    1、RDB

        快照形式,在指定的时间间隔内将内存中数据集写入磁盘中,保存到dump.rdb的二进制文件中,数据需要恢复时从磁盘中将快照文件直接读到内存中

        redis.conf文件中配置,如图:

        

        900秒内修改一次则save一次;

        运作:copy-on-write:redis调用fork()方法生成子进程---写数据到rdb文件---写完后将新rdb文件替换旧rdb文件

        用处:备份数据时间紧凑,保存了redis某个时间点上的整个数据集,适合用于备份和灾难恢复:

        RDB 可以最大化 Redis 的性能:父进程在保存 RDB 文件时唯一要做的就是 fork 出一个子进程,然后这个子进程就会处理接下来的所有保存工作,父进程无须执行任何磁盘 I/O 操作。RDB 在恢复大数据集时的速度比 AOF 的恢复速度要快。

        但数据量大,会丢失数据

    2、AOF:

        日志形式记录每个写操作,将每个写操作追加到aof文件中,redis启动时读取该文件进行重新构建数据

        redis.conf文件中进行配置,如图:

        

        appendonly no:不开启aof持久化方式

        appendfilename "appendonly.aof":写入的aof文件名称

        更新的方式:

          1.appendfsync always:每次修改都调用fsync命令将修改内容更新到aof文件中,慢,安全

          2.appendfsync everysec:每秒调用fsyn命令更新,足够快,故障时只丢失1秒数据

          3.appendfsync no:不执行更新,依靠操作系统进行刷新,更快,不安全


    展开全文
  • FileInputStream

    2020-12-26 12:19:39
    read(byte[] b):输入流中将最多b.length个字节的数据读入一个byte数组。 read(byte[] b, int ,off, int len):输入流中将最多len个字节的数据读入一个byte数组。 read(): import java.io

    java.io.FileInputStream

    • 文件字节输入流,万能的,任何类型的文件都可以采用这个流来读。
    • 字节的方式,完成输入的操作,完成读的操作(从硬盘—>到内存

    主要方法:

    • read():从输入流中读取一个数据字节
    • read(byte[] b):从输入流中将最多b.length个字节的数据读入一个byte数组中。
    • read(byte[] b, int ,off, int len):从输入流中将最多len个字节的数据读入一个byte数组中。
    read():
    import java.io.FileInputStream;
    
    public class FileInputStreamTest01 {
        public static void main(String[] args) {
            FileInputStream fis = null;
            try {  //main方法中抛出异常一般使用try...catch
                // 创建文件字节输入流对象
                fis = new FileInputStream("D:/javaIO");
                
                //读取流
                
                int readData = fis.read();  //read()返回下一个数据字节;如果已到达文件末尾,则返回-1
                System.out.println(readData);
                
                //再次调用
                readData = fis.read();
                System.out.println(readData);  //返回下一个字节
                
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                //在finally语句块当中确保流一定关闭
                if (fis != null) {  //避免空指针异常
                    //关闭流的前提是:流不是空的,流是null时没必要关闭
                    try {
                        fis.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    

    优化代码:

    import java.io.FileInputStream;
    
    public class FileInputStreamTest02 {
        public static void main(String[] args) {
            FileInputStream fis = null;
            try {
                fis = new FileInputStream("D:/javaIO");
                while(true) {
                    int readData = fis.read();
                    if(readData == -1) {  //如果为-1跳出循环
                        break;
                    }
                    System.out.println(readData); 
                }
                
                //改造while循环
                int readData = 0;
                while((readData = fis.read()) != -1) {
                    System.out.println(readData); 
                }
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (fis != null) {
                    try {
                        fis.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    
    read(byte[] b):

    (tempfile为项目下子建的文件里面有”abcdef“6个字节)

    /*
    int read(byte[] b)
       一次最多读取b.length个字节。
       减少硬盘和内存的交互,提高程序的执行效率
       往byte[]数组当中读
    */
    
    public class FileInputStreamTest03 {
        public static void main(String[] args) {
            FileInputStream fis = null;
            try {
                //相对路经是从当前所在的位置作为起点开始找
                fis = new FileInputStream("tempfile"); //tempfile文件就在该项目的根
                
                //开始读,采用byte数组,一次读取多个字节。最多读取“数组.length”个字节
          //如果文件中有6个字节数:123456
                byte[] bytes = new byte[4];  //准备一个4个长度的byte数组,一次最多读取4个字节。
                
                //这个方法的返回值是:读取到的字节数量。(不是字节本身)
                int readCount = fis.read(bytes);
                System.out.println(readCount); //第一次读取到了4个字节,返回4
                //将字节数组全部转换成字符串:写法有问题
                System.out.println(new String(bytes));  // 1234
                System.out.println(new String(bytes,0,readCount)); //正确写法
                
                readCount = fis.read(bytes);
                System.out.println(readCount); //第二次读取到了2个字节,返回2
                System.out.println(new String(bytes));  // 5634,56把12顶替
                System.out.println(new String(bytes,0,readCount)); //正确写法
                
                readCount = fis.read(bytes);
                System.out.println(readCount); //第三次1个也没读取到返回-1
                
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (fis != null) {
                    try {
                        fis.close();
                    }catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    

    优化后的代码:

    public calss FileInputStreamTest04 {
        public static void main(String[] args) {
            FileInputStream fis = null;
            try {
                fis = new FileInputStream("tempfile");
                //准备一个bytes数组长度
                byte[] bytes = new byte[4];
               /* while(true) {
                    int readCount = fis.read(bytes);
                    if(readCount == -1) {
                        break;
                    }
                    //把byte数组转换成字符串,读到多少个转换多少个
                    System.out.print(new String(bytes, 0, readCount));
                }*/
                //while循环转变
                int readCount = 0;
                while ((readCount = fis.read(bytes)) != -1) {
                    System.out.print(new String(bytes , 0 , readCount))
                }
            } catch (FileNOtFountException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (fis != null) {
                    try {
                        fis.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    
    available()和skip(long n)方法:
    • available:返回流当中剩余的没有读到的字节数量
    • skip:跳过几个字节不读。

    available():

    public calss FileInputStreamTest05 {
        public static void main(String[] args) {
            FileInputStream fis = null;
            try {
                fis = new FileInputStream("tempfile");
                //读取1个字节
                int readByte = fis.read();
                //还剩下可以读的字节数量是:5
                System.out.println("剩下多少个字节没有读:" + fis.available());  //返回没有读取的字节个数
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (fis != null) {
                    try {
                        fis.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    

    skip():

    public calss FileInputStreamTest05 {
        public static void main(String[] args) {
            FileInputStream fis = null;
            try {
                fis = new FileInputStream("tempfile");
                System.out.println("粽子节数量:" + fis.available());
                
                fis.skip(3);  //跳过三个字节
                System.out.println(fis.read());  //返回100
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (fis != null) {
                    try {
                        fis.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    
    展开全文
  • 输入流:从数据程序的流称之为输入流() 输出流:程序输出源的流称之为输出流(写) 流的类型划分 字节流(byte) 字符流(char) 4.** 功能划分** 节点流 处理流 节点流主要用于直接跟输入输出源...

    I/O流和序列化和线程相关知识

    I/O流

    Java中将不同的输入输出源抽象表示为流;
    流是一种从输入源到接收地的抽像概念;

    1. ** 输入输出源:**
      • 文件
      • 网络
      • 内存
    2. 从流向考虑(站在程序角度考虑)
      输入流:从数据源到程序的流称之为输入流(读)
      输出流:从程序到输出源的流称之为输出流(写)
    3. 从流的类型划分
      字节流(byte)
      字符流(char)
      4.** 从功能划分**
      节点流
      处理流
      节点流主要用于直接跟输入输出源对接,处理流用于对节点流或其他流进行包装处理。

    Java中的字节流主要包含两个抽象的流类型:

    • java.io.InputStream 是所有字节输入流的超类(最终父类)
    • java.io.OutputStream 是所有字节输出流的超类

    字节流一般用于操作二进制文件,比如图片,音频,视频等,在对数据读写时以字节为单位;

    字节流常见子类

    • FileInputStream
    • FileOutputStream
    • ByteArrayInputStream
    • ByteArrayOutputStream
    • BufferedInputStream
    • BufferedOutputStream

    字节输入流InputStream

    常见方法:

    • int available() 获取流中的可读字节数
    • void close() 关闭此输入流并释放跟流相关的系统资源
    • abstract int read() 从流中读取一个字节
    • int read(byte[] b) 从流中读取字节并存入字节缓冲区,返回实际读取字节数
    • skip(long n) 发生下一次读取之前跳过n个字节

    字节输出流OutputStream

    常见方法:

    • void close() 关闭此输出流并释放跟流相关的系统资源
    • void flush() 刷新此输出流并强制将缓冲区的数据写出到输出源
    • void write(byte[] b)将b.length个字节从数组中写出到输出源
    • void write(byte[] b,int offset,int len) 将数组b中len个字节从offset开始写出到输出源
    • abstract void write(int b) 将指定的字节写出到输出源

    使用字节输入流(InputStream)读取文件内容

    public class InputStreamDemo2 {
    
    	public static void main(String[] args) throws IOException {
    		
    		//根据提供的文件路径获取与基于该文件字节输入流
    		InputStream is = new FileInputStream("D:\\tempfile\\a.txt");
    		//声明字节缓冲区
    		byte[] buff = new byte[128];
    		//声明变量表示实际的读取字节数
    		int len = 0;
       //循环读取,将每次读取的内容装入字节缓冲区
    		while((len = is.read(buff)) != -1) {
    			String s = new String(buff,0,len);
    			System.out.println(s);
    		}
    		//关闭资源
    		is.close();
    	}
    }
    

    文件拷贝

    /**
    	 * 	将传入的源文件拷贝到指定的目录中
    	 * @param sourceFile 源文件对象
    	 * @param targetDir	目标目录对象
    	 */
    public static void copyFile(File sourceFile,File targetDir) {
        //判断目标目录是否存在,若不存在创建
        if(!targetDir.exists()) {
            targetDir.mkdirs();
        }
        //根据提供的源文件文件名,结合目标目录构建一个目标文件对象
        File target = new File(targetDir,sourceFile.getName());
        InputStream is = null;
        OutputStream os = null;
        try {
            //获取源文件的输入流
            is = new FileInputStream(sourceFile);
            //获取目标文件的输出流
            os = new FileOutputStream(target);
            //声明字节缓冲区
            byte[] b = new byte[1024];
            //声明临时变量标记当前读取的实际字节数
            int len = 0;
            System.out.println("开始拷贝...");
            while((len = is.read(b)) != -1) {
                //使用输出流将数组从0开始写入len个字节到目标文件
                os.write(b, 0, len);
            }
            System.out.println("拷贝完成!");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                //关闭资源
                if(Objects.nonNull(os)) {
                    os.close();
                }
                if(Objects.nonNull(is)) {
                    is.close(); 
                }
            } catch (IOException e) {
                e.printStackTrace();
            }			
        }
    
    }
    
    
    public static void main(String[] args) {
        File source = new File("D:\\素材\\音乐\\music素材\\梅艳芳 - 亲密爱人.mp3");
        File target = new File("d:\\mp3");
        copyFile(source,target);
    }
    

    字符流常见子类

    • FileReader
    • FileWriter
    • InputStreamReader
    • InputStreamWriter
    • BufferedReader
    • BufferedWriter

    字符输入流Reader

    常见方法

    • abstract void close() 关闭流
    • int read() 读一个字符
    • int read(char[] buf) 将流中的字符读取到字符数组,并返回读取的实际字节数
    • abstract int read(char[] c,int off,int len) 将流中的字符读取到字符中,从数组的off开始存储len个字符

    字符输出流Writer

    常见方法

    • Writer append(char c) 将指定的字符追加到流末尾
    • Writer append(charSequence cs) 将指定的字符序列(字符串)追加到流末尾
    • abstract void close() 关闭流先调用flush()
    • abstract void flush() 将缓冲区的数据强制通过流输出到输出源
    • void write(char[] c) 写入一个字符数组到输出流
    • void write(char[] c,int off,int len) 将字符数组c从off开始写入len位到输出流
    • void write(String str) 写入一个字符串到输出流

    处理流

    JavaIO中对流的功能划分又分为以下两种:

    • 节点流
    • 处理流

    节点流:

    • 节点流也是低级流,主要用于跟输入输入源直接对接,常见的节点流:
    • FileInputStream
    • FileOutputStream
    • FileReader
    • FileWriter
    • ByteArrayInputStream
    • ByteArrayOutputStream
    • CharArrayReader
    • CharArrayWriter
      处理流:
      处理流也称之包装流(用于处理其他流的流),用于将节点流或者其他流进行包装,以提高数据的传输效率或者转换流的类型,常见的处理流:
    • InputStreamReader
    • OutputStreamWriter
    • BufferedInputStream
    • BufferedOutputStream
    • BufferedReader
    • BufferedWriter
      转换流&缓冲流:
    public static void main(String[] args) throws IOException {
    
        //获取标准输入流(字节流)
        InputStream is = System.in;
    
        //字节流转换为字符流(转换流可以实现字节流和字符流之间的转换;不能转换流向)
        InputStreamReader isr = new InputStreamReader(is,"utf-8");
    
        //将字符流包装为字符缓冲流(装饰器模式)
        BufferedReader br = new BufferedReader(isr);
    
        String s = null;
        while((s = br.readLine()) != null) {
            if("quit".equals(s)) {
                System.out.println("bye !!!");
                System.exit(0);
            }
            System.out.println(s);
        }
    
    }
    

    将字符数据以字节的形式写入

    public static void main(String[] args) throws IOException {
        //需要写入文件的内容
        String msg = "长江长江,我是黄河,收到请回答!!!!";
        //目标文件
        File f = new File("d:/tempfile/b.txt");
    
        //字节输出流
        FileOutputStream fos = new FileOutputStream(f,true);
    
        //将字节流包装为字符输出流
        OutputStreamWriter osw = new OutputStreamWriter(fos);
    
        //将字符输出流包装为缓冲字符输出流
        BufferedWriter bw = new BufferedWriter(osw);
    
        bw.write(msg);
        //使用字符流时需要使用flush将缓冲区的数据强行写入目标输出源
        bw.flush();
        bw.close();
    }
    

    以上程序中在使用到转换流(InputStreamReader/OutputStreamWriter)的同时还使用到了缓冲流(BufferedReader/BufferedWriter);其中缓冲流是自带缓冲区的高级流,实现原理为内部自带字符(字节)缓冲区,以提高数据的读写效率。

    打印流

    打印流是一个特殊的流,java中打印只有输出没有输入;打印流包含字节打印和字符打印:

    • java.io.PrintStream
    • java.io.PrintWriter

    RandomAccessFile

    RandomAccessFile可以用于对文件进行读和写操作,另外也支持直接以基本数类型的原始方式(元数据)将数据写入文件,RandomAccessFile提供了两个构造器

    • RandomAccessFile(File file,String mode)
    • RandomAccessFile(String file,String mode)
      关于构造器中的参数,第一个为目标文件或者目标文件的所在路径,第二个参数为对文件操作模式,模式参考如下
    模式 解释
    r 以只读模式打开文件,不可在文件上发生写操作
    rw 以可读可写的模式打开文件
    rws 在rw基础上运行将数据结果,以及元数据同步到底层存储设备
    rwd 在rw基础上运行将数据结果同步到底层存储设备
    public class RandomAccessFileDemo {
    
        public static void main(String[] args) throws IOException {
    
            //根据提供的目标文件路径以及操作模式(r,rw)获取对象
            RandomAccessFile raf = new RandomAccessFile("d:/tempfile/a.txt","rw");
            byte[] b = new byte[1024];
            int len = 0;
            while((len = raf.read(b)) != -1) {
                String s = new String(b,0,len);
                System.out.println(s);
            }
    
            raf.write("hello".getBytes());
    
            raf.close();
        }
    
    }
    

    文件转码

    public class CharacterConvertor {
    
        /**
    	 * 	实现将一个源文件从一种特定编码转换为另一种特定编码并存储到指定的目录中
    	 * @param source	源文件
    	 * @param dir	目标目录
    	 * @param oldCharset	源文件的编码(GBK)
    	 * @param newCharset	新文件的编码(UTF-8)
    	 * @throws IOException 
    	 */
        public static void convertor(File source,File dir,String oldCharset,String newCharset) throws IOException {
    
            //获取源文件的字节输入流
            FileInputStream fis = new FileInputStream(source);
            //获取新文件的字节输出流
            FileOutputStream fos = new FileOutputStream(new File(dir,source.getName()));
    
            //将源文件的字节输入流使用源文件的编码转换为字符输入流
            InputStreamReader isr = new InputStreamReader(fis,oldCharset);
            //将目标文件的字节输出流使用特定的编码转换为字符输出流
            OutputStreamWriter osw = new OutputStreamWriter(fos,newCharset);
    
            char[] c = new char[512];
            int len = 0;
            while((len = isr.read(c)) != -1) {
                osw.write(c, 0, len);
                osw.flush();
            }
            osw.close();
            isr.close();
        }
    
        /**
    	 * 	将整个工作空间中的所有java文件全部转码为UTF-8,要求保持原来的目录结构
    	 * @param args
    	 * @throws IOException
    	 */
        public static void main(String[] args) throws IOException {
            //准备源文件
            File f1 = new File("D:\\项目资料\\教学项目\\java\\j2003\\lesson33\\src\\com\\softeem\\lesson33\\TestProperties.java");
            //准备目标目录
            File f2 = new File("C:\\Users\\Administrator\\Desktop");
            //转换
            convertor(f1, f2, "gbk", "utf-8");
        }
    }
    

    序列化

    Java的对象序列化实际就是将一个Java对象中的属性信息以元数据的方式写入文件(序列化),另外也可以以元数据的方式从输入源中读取对象数据(反序列化);Java中对象的序列化分为两个步骤:

    1. 让需要实现对象序列化的类实现Serializable接口
    2. 通过对象输出流将对象写入到指定输出源(ObjectOutputStream)

    Serializable

    ​ Serializable是一个标记型接口(内部没有任何方法需要实现);任何的类型如果需要实现对象序列化都需要从这个接口实现,常见的比如:String、Date、File、ArrayList、HashSet、HashMap都实现过该接口。

    注意事项:

    任何实现过Seriablizable接口的类都需要生成一个唯一的序列号,序列号的作用是用于再反序列化的时候进行对象校验的。

    另外如果有对源代码修改,同时也需要将序列号更新。
    对象序列化是对属性序列化,不是方法

    ObjectOutputStream

    java.io.ObjectOutputStream(对象输出流),ObjectOutputStream是一个处理流(包装流);可以用于对另一个输出源包装,以实现序列化的过程:

    File f = new File("d:/tempfile/savepoint.txt");
    FileOutputStream fos = new FileOutputStream(f);
    //将文件输出包装为对象输出流
    ObjectOutputStream oos = new ObjectOutputStream(fos);
    //写入对象到输出流中(对象序列化)
    oos.writeObject(h);
    oos.close();
    

    ObjectInputStream

    Java中实现对象的反序列化需要使用到:java.io.ObjectInputStream,该类可以对其他输入流包装为对象输入流,从而可以从输入流中读取到Java对象。

    //获取文件输入流
    FileInputStream fis = new FileInputStream(f);
    //将文件输入流包装为对象输入流
    ObjectInputStream ois = new ObjectInputStream(fis);
    //读取一个对象(反序列化)
    Object obj = ois.readObject();
    System.out.println(obj);
    ois.close();
    

    transient

    transient,瞬时,瞬间;如果在对象序列化时,有某些属性不需要序列化的时候,可以使用关键修饰

    /**
    * 	声明瞬时全局变量,对象序列化时不会将该属性序列化到输出流
    */
    private transient int flag;
    

    Externalizable

    java的对象序列化技术中还提供了另一个中序列化方式,即Externalizable,对需要实现对象序列化的类实现该接口,并且重写接口中的writeExternal(),readExternal()两个方法,让开发者手动写入或读取需要序列化的属性,具体使用如下:

    public class User implements Externalizable{
    
        private int id;
        private String name;
    
        //constract
        // settter/getter
    
        //toString
    
        /**
    	 * 	对需要序列化的属性手动写入
    	 */
        @Override
        public void writeExternal(ObjectOutput out) throws IOException {
            //手动写入需要序列化的属性
            out.writeInt(id);
            out.writeUTF(name);
        }
    
        /**
    	 * 	对需要反序列化的属性手动获取
    	 */
        @Override
        public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
            //读取需要反序列化的属性,主要顺序必须跟写入一致
            id = in.readInt();
            name = in.readUTF();
        }
    
    }
    

    线程

    并行与并发

    并发:多个任务,在同一个时间段之内执行

    并行:多个任务,在同一个时间点内执行

    进程与线程

    目前的操作系统是一个多进程的系统,在同一个时间之内可以运行多个任务,每一个任务都称之为进程

    进程:
    操作系统中正在执行的一个任务(程序),比如:QQ,微信,Eclipse,屏幕广播都称之为进程。
    一个进程下包含多个线程
    线程:
    线程是进程中的一条执行路径,比如360安全卫士,在杀毒的同时,清理垃圾,文件整理等操作
    一个线程必然包含在一个进程中

    线程的调度(CPU)

    • 平均分配执行时间(正常)
    • 抢占式运行(设置优先级)

    线程的状态

    一条线程从创建到销毁具备一条完整的生命周期,操作系统将线程的状态分为5种:

    1. 新建状态(线程刚创建)
    2. 就绪状态(线程启动)
    3. 运行状态(线程得到CPU的时间片)
    4. 阻塞状态(线程还未执行完,但是CPU已经将时间片分配其他线程)
    5. 死亡状态(线程执行完毕或者正常中断)

    注意事项:

    java的多线程机制中将线程分为6种状态:

    将阻塞状态划分为两种:

    1. 限时阻塞(在一个时间段之内阻塞,过了这个时间,重新进度调度队列)
    2. 无限阻塞(必须的到通知的情况下才能继续进度调度队列)

    线程创建

    java中的线程创建分为4种方式:

    1. 继承Thread类
    2. 实现Runnable接口
    3. 实现Callable接口,通过FuturaTask调度(JDK5新增并发编程)
    4. 使用线程池框架Executor创建(JDK5新增并发编程)

    守护线程

    守护线程也称之为后台线程,即为其他线程提供服务的线程;守护线程会随着主线程的结束而结束;如果需要设置一条线程为守护线程,则只需要调用setDaemon(true)即可

    public class ThreadDemo2 extends Thread{
    
    	@Override
    	public void run() {
    		for (int i = 0; i < 10000; i++) {
    			System.out.println("子线程===>"+i);
    			try {
    				sleep(50);
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    		}
    	}
    	
    	/**
    	 *  	文件拷贝:
    	 *  	1.主线程拷贝文件
    	 *  	2.子线程作为守护线程存在计算文本拷贝进度
    	 * @param args
    	 * @throws InterruptedException
    	 */
    	public static void main(String[] args) throws InterruptedException {
    		
    		ThreadDemo2 t = new ThreadDemo2();
    		//设置当前线程为守护线程
    		t.setDaemon(true);
    		t.start();
    		
    		for (int i = 0; i < 100; i++) {
    			System.out.println("主线程==>"+i);
    			Thread.sleep(10);
    		}
    	}
    }
    
    

    Join方法(插队)

    join方法用于将目标线程加入到正在执行的线程中,一旦join则目标线程会在正在执行的线程之前先执行完,类似插队概念

    线程中断

    在线程运行时需要将正在运行的线程中断,Threa类中提供了一些用于中断的方法:stop(),interrupt()但是这两个方法都具有一些固有的缺陷,stop()方法中断线程将会导致线程持有的对象锁被释放,从而使得对象成为共享对象导致并发安全问题;使用interrupt()方法时如果其他线程中断了当前正在运行的线程,将会抛出InterruptException;

    推荐的线程中断方法是采用标记中断:

    1. 在线程类中声明一个标记(整数,布尔等)
    2. 当标记为运行状态时线程正常执行
    3. 一旦将当前线程的标记状态修改为终止则不再执行线程
    public class InterruptDemo2 extends Thread {
    
        // 标记当前线程是否应该中断
        private boolean isOver = false;
    
        public void setOver(boolean isOver) {
            this.isOver = isOver;
        }
    
        @Override
        public void run() {
            int i = 0;
            //当标记中断状态为false时线程正常执行 
            while (!isOver) {
                // 执行业务操作
                i++;
                System.out.println("子线程" + i);
                try {
                    sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //一旦标记状态为false则结束
            System.out.println("子线程结束");
        }
    
        public static void main(String[] args) throws InterruptedException {
    
            InterruptDemo2 t = new InterruptDemo2();
            t.start();
    
            for (int i = 0; i < 100; i++) {
                sleep(200);
                System.out.println("主线程-->" + i);
                if (i == 20) {
                    // 标记t线程应该中断
                    t.setOver(true);
                }
            }
    
        }
    }
    
    展开全文
  • rar压缩软件.rar

    2016-02-13 10:52:44
    注释也可以使用 -z[名称] 开关从文件添加: 下列命令从 info.txt 文件添加一个注释: rar c -zinfo.txt dummy ch 改变压缩文件参数。 此命令能和大多数压缩文件变量开关一起使用修改压缩文件参数。对于象 -...
  • java源码包---java 源码 大量 实例

    千次下载 热门讨论 2013-04-18 23:15:26
    通过本源码可以了解Java如何产生单钥加密的密钥(myKey)、产生双钥的密钥对(keyPair)、如何保存公钥的字节数组、保存私钥文件privateKey.dat、如何用Java对象序列化保存私钥,通常应对私钥加密后再保存、如何...
  • WinRAR_4.0.exe

    2011-02-04 11:34:33
    注释也可以使用 -z[名称] 开关从文件添加: 下列命令从 info.txt 文件添加一个注释: rar c -zinfo.txt dummy cf 添加文件注释。当使用'v'命令时显示文件注释。文件的注释长度限制 32767 字节。 例子: ...
  • java源码包2

    千次下载 热门讨论 2013-04-20 11:28:17
    通过本源码可以了解Java如何产生单钥加密的密钥(myKey)、产生双钥的密钥对(keyPair)、如何保存公钥的字节数组、保存私钥文件privateKey.dat、如何用Java对象序列化保存私钥,通常应对私钥加密后再保存、如何...
  • java源码包3

    千次下载 热门讨论 2013-04-20 11:30:13
    通过本源码可以了解Java如何产生单钥加密的密钥(myKey)、产生双钥的密钥对(keyPair)、如何保存公钥的字节数组、保存私钥文件privateKey.dat、如何用Java对象序列化保存私钥,通常应对私钥加密后再保存、如何...
  • java源码包4

    千次下载 热门讨论 2013-04-20 11:31:44
    通过本源码可以了解Java如何产生单钥加密的密钥(myKey)、产生双钥的密钥对(keyPair)、如何保存公钥的字节数组、保存私钥文件privateKey.dat、如何用Java对象序列化保存私钥,通常应对私钥加密后再保存、如何...
  • 通过本源码可以了解Java如何产生单钥加密的密钥(myKey)、产生双钥的密钥对(keyPair)、如何保存公钥的字节数组、保存私钥文件privateKey.dat、如何用Java对象序列化保存私钥,通常应对私钥加密后再保存、如何...
  • 通过本源码可以了解Java如何产生单钥加密的密钥(myKey)、产生双钥的密钥对(keyPair)、如何保存公钥的字节数组、保存私钥文件privateKey.dat、如何用Java对象序列化保存私钥,通常应对私钥加密后再保存、如何...
  • 如何通过内存映像文件在进程间交换数据 如何通过消息实现进程间的通信 如何获取应用程序的实例句柄 如何获得应用程序主窗口的指针 如何获得其他应用程序的图标 怎样启动其他的应用程序 如何关闭其他已经打开的程序 ...
  • 通过本源码可以了解Java如何产生单钥加密的密钥(myKey)、产生双钥的密钥对(keyPair)、如何保存公钥的字节数组、保存私钥文件privateKey.dat、如何用Java对象序列化保存私钥,通常应对私钥加密后再保存、如何...
  • JAVA上百实例源码以及开源项目

    千次下载 热门讨论 2016-01-03 17:37:40
    通过本源码可以了解Java如何产生单钥加密的密钥(myKey)、产生双钥的密钥对(keyPair)、如何保存公钥的字节数组、保存私钥文件privateKey.dat、如何用Java对象序列化保存私钥,通常应对私钥加密后再保存、如何...
  • windowsnt 技术内幕

    2014-04-09 20:47:17
    理解引导分区与系统分区 NTFS简介 理解NFTS分区的多回收站 在NT考虑FAT文件系统特征 将NT计算机移植其他域 理解NT授予权 Windows NT安装类型简介 为3张安装盘创建备份盘 理解RISC体系结构下的Windows NT安装 ...
  • C#微软培训教材(高清PDF)

    千次下载 热门讨论 2009-07-30 08:51:17
    17.3 写 文 件 .222 17.4 异步文件操作 .227 17.5 小 结 .234 第十八章 高 级 话 题 .235 18.1 注册表编程 .235 18.2 在 C #代码调用 C++和 VB 编写的组件 .240 18.3 版 本 控 制 .249 18.4 代 ...
  •  6.2.5 文件操作  6.3 内核模式下的注册表操作  6.3.1 创建关闭注册表  6.3.2 打开注册表  6.3.3 添加、修改注册表键值  6.3.4 查询注册表  6.3.5 枚举子项  6.3.6 枚举子键  6.3.7 删除子项 ...
  •  6.2.5 文件操作  6.3 内核模式下的注册表操作  6.3.1 创建关闭注册表  6.3.2 打开注册表  6.3.3 添加、修改注册表键值  6.3.4 查询注册表  6.3.5 枚举子项  6.3.6 枚举子键  6.3.7 删除子项 ...
  • C#微软培训资料

    2014-01-22 14:10:17
    17.3 写 文 件 .222 17.4 异步文件操作 .227 17.5 小 结 .234 第十八章 高 级 话 题 .235 18.1 注册表编程 .235 18.2 在 C #代码调用 C++和 VB 编写的组件 .240 18.3 版 本 控 制 .249 18.4 代 ...
  • 10.2.5 将子查询因子化应用PL/SQL 270 10.3 递归子查询 273 10.3.1 一个CONNECT BY的例子 274 10.3.2 使用RSF的例子 275 10.3.3 RSF的限制条件 276 10.3.4 与CONNECT BY的不同点 276 10.4 复制CONNECT BY...
  • 10.2.5 将子查询因子化应用PL/SQL 270 10.3 递归子查询 273 10.3.1 一个CONNECT BY的例子 274 10.3.2 使用RSF的例子 275 10.3.3 RSF的限制条件 276 10.3.4 与CONNECT BY的不同点 276 10.4 复制CONNECT BY...
  • Visual C++编程技巧精选500例.pdf

    热门讨论 2012-09-01 15:01:50
    039 如何从文件对话框获取文件扩展名? 040 如何从文件对话框获取文件标题? 041 如何获取文件对话框选择的多个文件? 042 如何在程序启动时弹出文件打开对话框? 第4章 标题栏与菜单栏 043 如何获取标题栏高度? 044...
  • 网络组建域管理课件2

    2009-02-08 22:29:19
    如果某台工作站需要共享某数据库文件中的一个特定记录,它得送一个“整个文件”的请求给文件服务器,服务器将整个文件通过网络传送给该工作站,然后再运行工作站上的应用程序整个文件中搜寻出所需的记录。...
  • c#学习笔记.txt

    2008-12-15 14:01:21
    /* 你能看得出来,这不是一篇正规的技术文章,所以若你不小心里边读到了一个爱情故事,可不要奇怪。有很多人用程序来表述爱情,在其中我能看到有Money,有Girl,有一些还涉及到Sex,但是我没有找到Love,我始终相信...
  • 简单来说是本身可视为电子化的文件柜——存储电子文件的处所,用户可以对文件中数据运行新增、截取、更新、删除等操作。 常见的数据模型 1. 层次结构模型: 层次结构模型实质上是一种有根结点的定向有序树,IMS...

空空如也

空空如也

1 2
收藏数 37
精华内容 14
关键字:

从文件中将数据读到内存中