流---正则表达式----序列化---线程

流

**字节流（**默认不带缓冲区）都可以传

1InputStream(输入)
InputStream is = new FileInputStream(“F:/123.png”);

OutputStream（输出）
OutputStream os = new FileOutputStream(“F:/1.123.png”);

正则表达式
[] ---- 内容
//{} ---- 次数
//() ---- 整体
//^ ------ 首个
//$ ------ 末尾
列如：PrintWriter pw = null;
BufferedReader br = null;
PrintWriter pw1 =null;
try {
br = new BufferedReader(new FileReader(“F:/java.txt”));
//输出字符流
pw = new PrintWriter(“F:/123.txt”);
pw1 = new PrintWriter(“F:/234.txt”);
String str = null;
//取出没一行的值不等于空
while((str = br.readLine())!=null) {
System.out.println(str);
//正则表达式：第一位是1，第二位是3-9，后面9位是0-9
//[] ---- 内容
//{} ---- 次数
//() ---- 整体
//^ ------ 首个
//$ ------ 末尾
if(str.matches(“1[3-9][0-9]{9}”)) {
pw.println(str+“是”);
pw1.println(str);

			}else {
				pw.println(str+"No");
			}
			
		}
		pw.flush();
		pw1.flush();
		
	} catch (FileNotFoundException e) {
		e.printStackTrace();
	} catch (IOException e) {
		e.printStackTrace();
	}finally {
		try {
			br.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
		pw.close();
		pw1.close();
	}

字符流
字符流（默认自带缓冲区）不能传输二进制文件
Reader （输入）
Writer （输出）

BufferedReader:就多了这一个方法br.readLine()：只输出一行
实例：while((str = br.readLine())!=null) {
System.out.println(str);
}

文本文件：如果你能用文本编辑器打卡的就是文本文件------其他就是一些二进制的文件

创建文件夹，1个不用加s分之
f.mkdirs();
public static void main(String[] args){
solve(“F:/XAJ210301”);
}

public static void solve(String dir) {
	File f = new File(dir);
	solve(f);
}

**//递归**
//创建一个方法
private static void solve(File f) {
	//如果f是一个文件夹
	if(f.isDirectory()) {
		//File数组=f.安文件大小、名称、日期排序方法
		File[] fs = f.listFiles();
		//用for循环打印
		for(File c : fs) {
			//是文件夹在向下遍历一层
			solve(c);
		}
	}else {
		//如果这个文件结尾是以.txt结尾的就输出他的绝对路径
		if(f.getName().endsWith(".txt")) {
			System.out.println(f.getAbsolutePath());
		}
	}
}

序列化

内容：将内存中的对象转化成一个二进制的流,并对这个二进制的流进行操作的过程，叫做序列化
实例public static void main(String[] args) {
Person p = new Person(20,“shshsh”);
//写出某个文件的流
FileOutputStream fos = null;
//把一个对象变成字节流
ObjectOutputStream oos;
try {
fos = new FileOutputStream(“F:/person.soo”);
oos = new ObjectOutputStream(fos);
//把一个类的对象写入文件中
oos.writeObject§;
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}

反序列化：将一个二进制的流读取重新准化为堆里的对象
实例：ObjectInputStream ois =null;
FileInputStream fis = null;
try {
//反序列化
//文件输入流
fis = new FileInputStream(“F:/person.soo”);
//对象输入流
ois = new ObjectInputStream(fis);
//创建O对象将一个二进制转化成对象
Object o = ois.readObject();
//System.out.println(o.getClass());
Person p = null;
//判断对象o是Person类的实例
if(o instanceof Person) {
//将o对象转化成Person 然后在将o给p
p = (Person)o;
}
System.out.println(p.name);
System.out.println(p.age);
}catch (Exception e) {
e.printStackTrace();
}

**持久化：**保存二进制流的方式（文件，网络，数据库）

被static和final修饰的会不会被序列化：不会（会但是不能被反序列化）

实现了Serializable才可以被序列化

线程

进程：是管理任务的最小单元

线程：是CPU处理任务的最小单元
异步线程：相互之间没有任何联系，没有影响，提高效率，（不安全
**同步线程：**效率太低，共同使用的某个数据区，得到的结果是有效的，(安全的)

怎么实现多线程
创建一个类继承JAVA中的Thread（重新run方法）
run方法就是这个子线程线程的入口方法
MyThread m = new MyThread();//在main创建一个对象线程
m.start();//启动一个子线程

所以的阻塞方法只会阻塞当前线程！！！

线程睡眠周期
新建—准备—运行—阻塞—死亡

！！！1.程序计数器 本地方法栈 虚拟机栈（独占） 2. 堆 方法区（共享）

快速失败（fail—fast）

      在用迭代器遍历一个集合对象时，如果遍历过程中对集合对象的结构进行了修改（增加、删除），则会抛出Concurrent Modification Exception。

安全失败（fail—safe）

  采用安全失败机制的集合容器，在遍历时不是直接在集合内容上访问的，而是先复制原有集合内容，在拷贝的集合上进行遍历。

方法
Thread.currentThread();//可以拿到当前线程的名字
getName();//取名字
Thread.sleep(1000);当前线程睡眠，一毫秒为单位
t.wait();（会释放锁！！！）//等待，会让出锁，让出所有的资源(必须要在synchronized（监视器）)（在生命周期的超时等待里面） 同步
sleep和wait之间的区别是一个静态和动态，一个是Thread调用的，一个必须在监视器里调用(对象调用)，一个不让资源，一个让出所有资源
t.yield();//让出当前线程的执行状态，让别人去执行
c.notify();//通知刚才阻塞的线程开始执行（只通知一个）同步
c.notifyAll()😕/大家全部都可以执行，谁快谁先，执行完了后面在上。
t.run();//(启动在main里)
关键字：synchronized是依靠字节码里的监视器加锁，如果抛出异常的时候会释放锁
类：ReentrantLock（抽象队列同步器）这个利用java的执行流程，要手动解锁。抛出异常的把放锁方进finally里
lock.getQueueLength();//取等待解锁的人数
lock.unlock();//解锁
getHoldCount();//取出锁的次数
setDaemons()//守护线程方法
getHoldCount();//取出锁的次数
实例：public void run() {
//加锁
try {

		lock.lock();
		for (int i = 0; i < 1000; i++) {
			//输出他的当前线程和名字
			System.out.println(Thread.currentThread().getName()+" "+i);
		}
	} catch(Exception e) {
		e.printStackTrace();
	}finally {
		int i = lock.getHoldCount();//取出锁的次数
		for (int j = 0; j < i; j++) {
			lock.unlock();//解锁
		}
		//lock.getQueueLength();//取等待解锁的人数
		
	}
	
}

锁
可重入锁的工具实现代码同步
//ReentrantLock（排它锁）
底层实现是AQS-----安全，效率低
(写锁) 是排它锁：加上写锁别人就加不上锁
共享锁（读锁）异步
CAS(compareAndSwapInt)（C）(乐观锁):比较并替换------我认为你拿走了这个东西不会改他，保证并发过程中的最终结果一致 同步 （浪费了算力）
AAB:解决方法引入版本号
悲观锁：你拿走我就认为你会改

线程安全容器
Hashtable
底层用CAS实现的线程安全但是效率慢
ConcurrentHashMap
(支持多线程并发)用CAS保证线程安全的，效率高，在多线程并发操作时不会报异常
底层：是由CAS和synchronized（锁实现的）线程安全，

互斥锁（代码块，方法）(必须要锁同一个对象)；synchronized
synchronized(mutex)括号里面必须传一个堆里的对象
被sychronized修饰的才能实现同步线程
锁一个类型synchronized (Mutext.class)（其实这个对象是在方法区里）
锁对象
synchronized (m)

AQS(AbstractQueuedSynchronizer):抽象队列同步器，属于抽象类
公平锁(FairSync):
非公平锁(NoFairSync):

List
Collections.synchronizedList(list);//线程安全可并发的list
ArrayList:支持并发但是他是线程不安全的
CopyOnWriteArrayList()！！！写数组的拷贝，支持高效率并发且是线程安全的,读操作无锁的ArrayList。所有可变操作都是通过对底层数组进行一次新的复制来实现。

CountDownLatch cdl = new CountDownLatch(5);//创建这个计数器对象
方法！！！
cdl.countDown();//是一次性的，这个会让上面的值每次减1倒计时到0的时候，所有被await()阻塞的线程都会解除，并发（！！！先调用这个）
cdl.await();//当前线程会被阻塞住

CyclicBarrier cb = new CyclicBarrier(5);//循环栅栏：每次够了5次才能放出线程
实例！！for (int i = 0; i < 27; i++) {
System.out.println(“新的线程已经创建：”+i);
Thread.sleep(1000);
TestThread tt = new TestThread(cb);
tt.start();
}

Semaphore semaphore = new Semaphore(5);//信号量：同时最大有几个线程在执行
方法！！！
semaphore.acquire();//获得一个信号
semaphore.release();//释放

线程创建方式
创建一个类去继承Thread
实现一个 Runnable将Runnable赋给Thread;(扩展性更高)
实现Callable:有返回值，可以被取消的
ExecutorService(线程池):

线程池
(corePoolSize(核心池大小),maximumPoolSize(最大池大小),keepAliveTime(线程保持活着的时间), unit(时间单位), workQueue(阻塞队列), threadFactory(如何创建你在这个线程里的线程(可以不写)), handler(拒绝执行处理器))
列子：！！ThreadPoolExecutor tep = new ThreadPoolExecutor(10,20,100, TimeUnit.SECONDS,
new ArrayBlockingQueue<>(20),
null,new ThreadPoolExecutor.DiscardPolicy());
拒绝方式：
1–ThreadPoolExecutor.AbortPolicy()//放不进来我就将他丢弃抛个异常
2–CallerRunsPolicy()//默默的抛弃策略
3–DiscardOldestPolicy()//存活时间最长的干掉，把当前任务加到尾巴上
4–DiscardPolicy()//你在调用我，我的任务队列满了，自己干去
1.ExecutorService es = Executors.newSingleThreadExecutor();//单一线程
es.submit(task)//执行的Callable

	es.execute(command);//执行的Runnable
2.xecutorService es = Executors.newFixedThreadPool(5);//写几个就是几个线程
3.ExecutorService es = Executors.newCachedThreadPool();//(缓冲型的线程池)不设置大小，超过一定时间没有任务干就会杀死线程
ScheduledExecutorService es = Executors.newScheduledThreadPool(5);//定时任务，核心的线程数（5代表最少有5个）
	es.schedule(callable(), delay(时间), unit(单位));