线程+锁+流知识整合化解你的小疑惑

一、线程

1、概念：CPU进行调度的最小单位
注：一个进程中至少有一条线程，该线程有JVM发起，称之为主线程
2、线程的生命周期
 ① 创建线程对象： 新生    new born
 ② 用start方法后： 就绪     ready
 ③ CPU调度后：  运行    running
           阻塞   blocked
  ④ run方法结束：  死亡   dead
3、如何开启一个线程

① 匿名内部类创建线程
			Thread thread = new Thread(){
				@Override
				Public void run(){
						...
				}
			};
			Thread.start();
	
②自定义类继承Thread
		class MyThread extends Thread{
				//自定义属性...
				//自定义方法	...@Override
			Public void run(){
			...
			}
		}
		Thread thread = new MyThread();
		Thread.start();

③自定义类实现Runable接口
		class Myrun implements Runable{
				//自定义属性
				...
				//自定义方法
			...
	
		@Override
		Public void run(){
			...
			}
		}
		Runable mr = new MyRun(...); 
		Thread thread = new Thread(mr);
		Thread.start();

④自定义类实现Callable接口
		class MyCall implement Callable<T>{
				//自定义属性
				...
				//自定义方法
				...
	
		@Override
		Public void run(){
			...
		}
	}
	Mycall mc = new new MyCall(...);
	Future<T> fu = esf.submit(mc);
	T t = fu.get();

二、锁

1、分类：
 1） 乐观锁
 2） 悲观锁
 a. 共享锁：读锁
 b. 排它锁：写锁
 i.公平锁
 ii.非公平锁
2、关键字：Synchronized

	1）	同步方法
			Public synchronized void show(){
				This.wait([int millisec]);
				...
				This.nodify(); / this.notifyAll();
				}
	2） 同步代码块
				Synchronized（locker）{
				Locker.wait([int millisec]);
				...
				This.nodify(); / this.notifyAll();
				}
	3） 同步代码块2
	Lock lock = new ReentranLock(boolean fair);悲观排他true公平，false不公平
	Lock lock = new ReentranLock();悲观排它非公平锁
	Condition cond = lock.newCondition();
				Try{
				Lock.lockINteruptedly();
				Cond.await();
				...
				Cond.signal();	/	cond.signalAll;
				}catch(...){
				...
				}finally{
					Lock.unlock();
				}

3、读写锁

ReentrantReadWriteLock rw = new ReentrantReadWriteLock(true);
ReentrantReadWriteLock.ReadLock readlock = rw.readLock();
ReentrantReadWriteLock.WriteLock writeLock = rw.writeLock();

三、流

1、概念：一组有序的数据序列（字节数组）
2、分类：
 ① 方向
 1） 输入：从外到内   XxxInputStream/XxxReader
 2） 输出：从内到外   XxxOutputStream/XxxWriter
 ② 内容
 1） 字节流：byte[]   XxxInputStream/XxxOutputStream
 2） 字符流：char[]   XxxReader/XxxWriter
 ③ 功能
 1） 节点流：直接面向数据源的流（基础流）
 2） 处理流：扩展了节点流在某些特定领域的操作
 ④ 是否依赖网络
 1）本地流：文件流
  2）网络流：
3、文件流

目录
1）	Director
	a.	File dir = new File(String path);//创建目录的对象
	b.	Boolean exists = dir.exists();//目录是否存在
	c.	Boolean isDir = dir.idDirectory();//是够是目录
	d.	File[] whats = dir.listFiles([FileNameFileter/FileFilter filter]);
	e.	Boolean succes = dir.mkdir(s)();
	a)	mkdir：创建最后一级目录
	b)	mkdirs：创建所有不存在的目录
	f.	关于相对路径和绝对路径
	a)	普通java功能：相对路径为项目的根路径
	b)	绝对路径：从分区根目录开始的路径
文件
2）	File
	a.	File file = new File(String path);//创建文件对象
	b.	Boolean exists = file.exists();//文件是否存在
	c.	Boolean isFile  = file.isFile();//是否是文件
	d.	String parentDir = file.getParent();//获取父目录字符串
	e.	File parent = file.getParentFile();//获取父目录对象
	f.	Strign fileName = file.getName();//获取文件名称
	g.	Long realSize = file.length();//获取文件实际字节数
	h.	Long freeSpace = file.getFreeSpace();//获取文件可存剩余字节数
	i.	Long lastMod = file.lastModfiled();//获取文件上一次修改的长整时间
	

3）	字符文件流
	a.	字符文件输入流
	a)	FileReader fr = new FileReader(String/File path);
	b)	Int len  = fr.read(char[] cs);//len：实际读取的字符数，-1表示文件结尾。
	c)	Fr.close（）：释放文件资源
	b.	字符文件输出流
	a)	FileWriter fw = new FileWriter(String/File path,boolean append);//默认为覆盖写模式；append：true表示追加模式
	b)	Fw.write(char[] cs[,int beginIndex,int count]);
	c)	Fw.write(String str[,int beginIndex,int count])
	d)	Fr.close（）：释放文件资源
	c.	字符缓存读写流
	a)	读
	1）	BufferReader br = new BufferReader(FileReader fr);
	2）	String line = br.readLine();//实际读取行的内容，null表示文件结尾
	3）	br.close();//同时关闭关联流资源，并释放文件资源
	b)	写：
	1）	BufferedWriter bw = new BufferedWriter(FileWriter fw);
	2）	Br.newLine();//添加新航
	2）	。。。
	3）	Br.close（）


4）	字节文件流
	a.	输入
	a)	fileInputStream fis = new FileInputStream(String/File src);
		BufferedInputStream bis = new BufferedInputStream(fis,[int size]);
		如果不存在则报：java.io.FileNotFoundException
	b)	int len = fis.read(byte[] bs);
	c)	fis.close();
	b.	输出
	a)	FileOutputStream fos = new FileOutputStream(String/File dest);
		BufferedOutputStream bis = new BufferedOuputStream(fis,[int size]);
		如果dest的目录不存在则报：java.io.FileNotFoundException
	b)	Fos.write(byte[]bs,int beginIndex,int count)
	c)	Fos.close();