DAY21:Properties,其它流,多线程

一.Properties

 Properties:本质上是Map容器,提供了可以快速写出和从文本中获取键值对的方法

示例代码:

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Properties;

import com.util.Util;

public class PropertieStu {
	/*Properties:本质上是Map容器,提供了可以快速写出和从文本中获取键值对的方法
	 * 
	 */
	public static void main(String[] args) {
		//writePro();
		readPro();
	}
	//写出键值对
	public static void writePro(){
		Properties pro = new Properties();
		pro.put("蜘蛛侠", "张俊男");
		pro.put("黑寡妇", "Jeff");
		pro.put("美队","戴德金");
		pro.put("绿巨人", "黄志宇");
		OutputStream os = null;
		try {
			os = new FileOutputStream("src/com/day21/hero.properties");
			pro.store(os, "超级英雄");
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{
			Util.closeStream(os);
		}
	}
	//读取键值对
	public static void readPro(){
		Properties pro = new Properties();
		InputStream is = null;
		try {
			is = new FileInputStream("src/com/day21/hero.properties");
			pro.load(is);
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{
			Util.closeStream(is);
		}
		System.out.println(pro);
	}
}

二.其他流
 1.数组流:默认数据源为内存,将数组写入内存或者从内存读取

    用到的类:ByteArrayOutputStream  ByteArrayInputStream(字节数组输入输出)
                   CharArrayReader            CharArrayWriter          (字符数组输入输出)
  2.系统流:数据源为当前系统的流(控制台)

     每个 Java 程序运行时都带有一个系统流，系统流对应的类为 java.lang.System。Sytem 类封装了 Java 程序运行时的 3 个系统流，分别通过 in、out 和 err 变量来引用。这些变量的作用域为 public 和 static，因此在程序的任何部分都不需引用 System 对象就可以使用它们。

• System.in：标准输入流，默认设备是键盘。
• System.out：标准输出流，默认设备是控制台。
• System.err：标准错误流，默认设备是控制台。
• 详解点击

  3. 打印流:printStream     printWriter   不会出现IO异常

      打印流详解

 示例代码:

​
package com.day21.other_stream;

import java.io.BufferedReader;
import java.io.CharArrayReader;
import java.io.CharArrayWriter;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;

import com.util.Util;
public class OtherStream {
	public static void main(String[] args) throws IOException {
		demo2();
	}
	//数组流
	public static void demo(){
		CharArrayWriter cw = new CharArrayWriter();
		try {
			cw.write("你们好好");
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{
			Util.closeStream(cw);
		}
		//从内存中取出数组
		CharArrayReader cr = new CharArrayReader(cw.toCharArray());
		char[] arr = new char[2];
		int len;
		try {
			while((len=cr.read(arr))!=-1){
				System.out.println(new String(arr,0,len));
			}
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{
			Util.closeStream(cr);
		}
		
	}
	public static void demo1(){
		PrintWriter pw = null;
		try {
			pw = new PrintWriter("src/com/day21/a.txt");
			pw.write("我是一个大帅哥");
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{
			Util.closeStream(pw);
		}
	}
	public static void demo2() throws IOException{
		System.out.println("啊哈哈哈");
		System.err.println("大大大阿达");
		//自己写系统输入
		InputStream is = System.in;
		BufferedReader br = null;
		br = new BufferedReader(new InputStreamReader(is));
		System.out.println("请输入您的名字");
		String name = br.readLine();
		System.out.println(name);
	}
}












​

 

三.多线程

1.什么是线程,什么是进程,以及两者区别?

进程：进程指正在运行的程序。确切的来说，当一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能。

线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

2.什么是多线程?(该问题转载)

单线程程序：即，若有多个任务只能依次执行。当上一个任务执行结束后，下一个任务开始执行。如，去网吧上网，网吧只能让一个人上网，当这个人下机后，下一个人才能上网。

多线程程序(高并发)：即，若有多个任务可以同时执行。如，去网吧上网，网吧能够让多个人同时上网。

高并行:存在多个进程同时执行,例如多核心的Cpu

高并发:只有一个进程在运行,所有线程交替占用资源(优化等待时间,缩短共同等待时间);

 

  

3.多线程实现的两种方式:

方式一:1.extends Thread 类2.重写run方法3.start方法启动线程

示例代码:

public class ThreadStu {
	public static void main(String[] args) {
			OldWoman ow1 = new OldWoman("俊男大妈");
			OldWoman ow2 = new OldWoman("Jeff大妈");
			OldWoman ow3 = new OldWoman("德金大妈");
			ow1.start();
			ow2.start();
			ow3.start();
	}
}


public class OldWoman extends Thread{
	String name;
	public void robWatermelon(){
		for (int i = 1; i < 4; i++) {
			try {
				Thread.sleep(Util.getRandom(1000,5000));//设置缓冲时间
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(name+"抢了第"+i+"个西瓜");
		}
	}
	public OldWoman(String name) {
		super();
		this.name = name;
	}
	@Override
	public void run() {
		robWatermelon();
	}
	
}

	
}

方式二:1.implements Runnable 2.实现run方法 3.新建线程类对象,将当前对象传入构造器 4.调用start

示例代码:

public class ThreadStu {
	public static void main(String[] args) {
			OldWoman ow1 = new OldWoman("俊男大妈");
			OldWoman ow2 = new OldWoman("Jeff大妈");
			OldWoman ow3 = new OldWoman("德金大妈");
			new Thread(ow1).start();
			new Thread(ow2).start();
			new Thread(ow3).start();
	}
}

import com.util.Util;

public class OldWoman implements Runnable{
	String name;
	public void robWatermelon(){
		for (int i = 1; i < 4; i++) {
			try {
				Thread.sleep(Util.getRandom(1000,5000));//等待时间
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(name+"抢了第"+i+"个西瓜");
		}
	}
	public OldWoman(String name) {
		super();
		this.name = name;
	}
	@Override
	public void run() {
		robWatermelon();
	}
	
}

 

Thread与Runnable对比: 

Thread优点:代码简洁,节约内存
 Runnable优点:是接口,可以多实现,不会占用父类的位置

4.多线程常用API

Thread类的常用api

activeCount()返回当前线程的线程组中活动线程的数目,包括执行线程。

currentThread()返回对当前正在执行的线程对象的引用。

getId() 返回该线程的标识符。

getName()返回该线程的名称。

getPriority() 返回线程的优先级。优先级为(1-10).

interrupt()中断线程。该方法不是中断线程,功能同下

interrupted()测试当前线程是否已经中断。

isDaemon() 测试该线程是否为守护线程。

join(long millis)等待该线程终止的时间最长为 millis 毫秒。参数可以为空,为等待该线程终止.

setDaemon(boolean on)将该线程标记为守护线程或用户线程

setName(String name) 改变线程名称，使之与参数 name 相同。

setPriority(int newPriority) 更改线程的优先级

sleep(long millis)在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。

yield() 暂停当前正在执行的线程对象，并执行其他线程。