CoreJava学习笔记12

死锁问题

多线程不释放自己拥有的锁标记，而想申请其他线程拥有的锁标记，就会造成死锁。

没有获得加锁对象的锁标记的线程,不能访问只有获得该对象所标记才能访问的同步方法,但可以访问这个对象的非同步的方法。

死锁的两种处理方法
统一排列锁顺序(解决不同方法中对多个共享资源的访问)
对象1的方法
synchronized(a)
synchronized(b)
对象2的方法
synchronized(a)
synchronized(b)

java线程间通信(也就是线程间的相互协调)

等待通知机制

线程间通信使用的空间称之为对象的等待对列（wait pool），该队列也是属于对象的空间的。

进入等待池

使用Object类中wait()的方法，在运行状态中，线程调用wait()，此时表示线程将释放自己所有的锁标记和CPU的占用，同时进入这个对象的等待池。等待池的状态也是阻塞状态，只不过线程释放自己的锁标记。在对该对象加锁的同步代码块里，才能调用该对象的wait()方法，表示线程将会释放所有锁标记，进入等待队列，线程将进入等待队列状态。

一个线程进入了对一个对象加锁的同步代码块，并对该对象调用了wait()方法，释放自己拥有的所有锁标记，进入该对象等待队列，另一个线程获得了该对象的锁标记，进入代码块对该对象调用了notify()方法（对该对象调用了notifyAll()方法，会释放等待队列里所有的线程），对该对象调用方法的线程也不会释放所拥有的锁标记（对自身没有影响），也就是从等待队列里释放出一线程，释放出的这个线程要继续运行也就还要进入那个同步代码块，因为得不到要访问代码块对象的锁标记，而进入该对象的锁池，等待所标记释放。

注意：用notifyAll()取代notify()，因为在调用notify()方法时，是由系统决定释放出哪个线程。

退出等待池进入锁池

注意：只能对加锁的资源进行wait()和notify()。
1) wait()：交出锁和CPU的占用，进入该对象的、等待队列。
2) notify()：从对象的等待队列中释放任意的一个线程。
3) notifyAll(): 从对象等待队列中释放所有线程并放到锁池中。


Java的I/O流与文件


Java中的文件操作
     
File类（java.io.File）可表示文件或者目录（在JAVA中文件和目录都属于这个类中，而且区分不是非常的明显）。

File下的方法是对磁盘上的文件进行磁盘操作，但是无法读取文件的内容。

注意：File类的对象实施表示一个文件并不是真正的文件，只是代理而已，通过代理来操作文件创建一个文件对象和创建一个文件在JAVA中是两个不同的概念。前者是在虚拟机中创建了一个文件，但却并没有将它真正地创建到OS的文件系统中，随着虚拟机的关闭，这个创建的对象也就消失了。而创建一个文件才是在系统中真正地建立一个文件。

例如：
File f=new File(“11.txt”);//创建一个名为11.txt的文件对象
f.CreateNewFile();//真正地创建文件

File类的方法

boolean createNewFile() //创建文件
boolean mkdir() //创建目录
boolean mkdirs() //创建多个目录
boolean delete() //删除文件，删除的是创建File对象时指定与之关联创建的那个文件。
boolean deleteOnExit(); //在JVM进程退出的时候删除文件，这样的操作通常用在临时文件的删除。
String[] List()：//返回当前File对象下所以显文件和目录名（相对路径）
File[] ListFiles()：//返回当前File对象（必须是目录）所有Files对象，可以用getName()来访问到文件名。
isDirectory()和isFile()//来判断究竟是目录还是文件。
String getParent()//得到父类文件名，只有在构造对象时传入了Parent对象才有。
File getParentFile()//父路径名的抽象路径名，如果没有指定Parent对象，则返回 null。
String getPath()//获得相对路径。
exists() //判断文件或文件夹是否存在。
getAbsolutePath() //获得文件的绝对路径

使用File类的实例
例：这个类是实现了删除_desktop.ini文件的功能

import java.io.*;
public class LsitFile {
	public static void main(String[] args) throws Exception{
		File f=new File("C:\\");
		print(f);
	}
	static void print(File f){
		File[] fs=f.listFiles(new MyFilter());
		for(int i=0;i<fs.length;i++){
			if (fs[i].isFile()){
				fs[i].delete();
			}
			else{
				print(fs[i]);
			}
		}
	}
}

class MyFilter implements FileFilter{
	public boolean accept(File arg0) {
		if (arg0.isDirectory()) return true;
		String name=arg0.getName();
		if (name.equals("_desktop.ini")) return true;
		else return false;
	}
}

处理跨平台性

对于命令：File f2=new file(“d:\\abc\\789\\1.txt”)
这个命令不具备跨平台性，因为不同的OS的文件系统的分隔符是不相同。
使用file类的separtor属性，返回当前平台文件分隔符。
File newD = new File("aa"+File.separator+"bb"+File.separator+"cc");
       File newF = new File(newD,"mudi.txt");
       try{
       newD.mkdirs();
       newF.createNewFile();
       }catch(Exception e){}

Java中的I/O流

Java中的I/O流是用来JVM（Java虚拟机）访问虚拟机外部数据源的。
1，按数据流向分
输入流，从外部数据源读入JVM
输出流，从JVM输出到外部数据源。

2，按数据单位分
字节流：以字节为单位进行数据传输
字符流：以字符为单位进行数据传输

3，按流的功能分
节点流：可以实现数据输入输出的流
过滤流：在节点流的基础之上添加功能的流，其本身是无法实现输入输出的，他必须借助于节点流才能实现输入输出的功能。

字节输入流：

InputStream类 （抽象类）
所有字节输入流的父类

io包中的InputStream为所有字节输入流的父类。
int read();读入一个字节（每次一个）；
可先使用new  byte[]，调用read(byte[] b)，byte[]数组长度决定了可以读取到的最大字节数，用来调整效率。read (byte[])返回值可以表示有效数；read (byte[])返回值为-1表示结束。

字节输出流：io包中的OutputStream位所有字节输入流的父类。Write和输入流中的read相对应。

在流中close()方法由程序员控制。因为输入输出流已经超越了VM的边界，所以有时可能无法回收资源。
原则：凡是跨出虚拟机边界的资源都要求程序员自己关闭，不要指望垃圾回收。
以Stream结尾的类都是字节流。
如果构造FileOutputStream的同时磁盘会建立一个文件。如果创建的文件与磁盘上已有的文件名重名，就会发生覆盖。
用FileOutputStream中的boolean，则视添加情况，将数据覆盖重名文件还是将输入内容放在文件的后面。（编写程序验证）


如：FileInputStream,ObjectInputStream,PipedInputStrean都是InputStream类的子类。

1) 三个基本的read()方法
      a. int read(): 从流里读出的一个字节或者-1（返回-1表示数据已经读取完毕）;
      b. int read(byte[])：将数据读入到字节数组中，并返回所读的字节数; （期望读了多长）
      c. int read(byte[], int , int)：两个int参数指定了所要填入的数组的子范围。
2) 其它方法
      a. void close(): 关闭流，如使用过滤器流，关闭最外部的流，会关闭其余的流。
      b. int available(): 返回可从流中读取的字节数。
      c. void skip(long): 丢弃了流中指定数目的字符。
      d. boolean markSupported()
      e. void mark(int)
      f. void rese()

OutputStream类（抽象类）
所有字节输出流的父类。

1) 三个基本的write()方法
      a. void write()
      b. void write(byte[])
      c. void write(byte[], int , int)
2) 其它方法
      a. void close(): 关闭流，如使用过滤器流，关闭最外部的流，会关闭其余的流。
      b. void flush(): 允许你强制执行写操作。
注意：在流中close()方法由程序员控制。因为输入输出流已经超越了JVM的边界，所以有时可能无法回收资源。
原则：凡是跨出虚拟机边界的资源都要求程序员自己关闭，不要指望垃圾回收。

基本输入输出所使用的类的介绍：

FileInputStream和FileOutputStream （文件输入输出流）

以上两个是字节流
1) 结点流，可以对磁盘文件进行操作。
2) 要构造一个FileInputStream, 所关联的文件必须存在而且是可读的。
3) 要构造一个FileOutputStream而输出文件已经存在，则它将被覆盖。

FileInputStream infile = new FileInputStream("myfile.dat"); 
   	FIleOutputStream outfile = new FileOutputStream("results.dat"); 
	FileOutputStream outfile = new FileOutputStream(“results.dat”,true);
	参数为true时输出为添加，为false时为覆盖。
  
import java.io.*;
public class FileCopy {
	public static void main(String[] args) {
		FileInputStream fi = null;
		FileOutputStream fo = null;
		try {
			fi = new FileInputStream(args[0]);
			fo = new FileOutputStream("copy_"+args[0]);
			byte[] bs=new byte[1024];
			int i;
			while((i=fi.read(bs))!=-1){
				fo.write(bs,0,i);
			}
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	
		finally{
			if(fi!=null)
				try {
					fi.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			if(fo!=null)
				try {
					fo.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		
	}
}