Java | Stream流、泛型、多线程 | 整理自用

 

1、lambda 表达式

lambda 的延迟执行

可以对程序进行优化，尤其是使用 if {} else {} 条件判断，先判断条件是否成立，再传入计算好的参数。

 

functionName( paramters, () -> { } );

 

2、stream 流式思想

stream 是jdk8之后出现的语法

拼接流式模型：建立一个生产线，按照生产线来生产商品

 

 

 经过了过滤、映射、跳过、计数等多步操作，集合元素的处理方案

filter、map、skip，得益于lambda的延迟执行特性。

（1） 获取流  

数据源流的来源：集合、数组

java.util.stream.Stream<T> 

// 所有的Collention 集合 (   list, map, set..   )都可以通过stream默认方法获取流
ArrayList<String> arrStr = new ArrayList();		
stream<String> stream1 = arrStr.stream();

// Stream接口的静态方法 of 可以获取数组对应的流
Stream<Integer> Stream2 = Stream.of(1, 4, 3, 5, 5);

// Stream 流只能使用一次，使用完之后就直接关闭了。即

Stream<String> stream3 = Stream.of("1", "2", "9", "4");
stream3.forEach((String str)-> {
	System.out.println(str);
});


// 再重新打印一次，输出异常
stream3.forEach((String str)-> {
	System.out.println(str);
	
});

 

（2）取用前几个：limit  如果当前长度大于参数进行截取，否则不截取。limit 是一个延迟方法，返回的是一个新的流

Stream<String> stream4 = stream3.limit(2);
stream4.forEach( str -> System.out.println(str) );

 

（3）跳过前几个：skip  与 limit 相反

 

 

（4）流拼接： concat

 

 java 泛型

 java泛型不允许静态化，类中含有 static 会报错：

// 分类：
// 1、泛型类
public class 类名<T> {

}

// 2、泛型接口
public interface Generator<T> {

}

// 3、泛型方法

 

类型通配符 ?

区别：
<? extends T> 该通配符所代表的类型是T类型的子类

<? super T> 该通配符所代表的类型是T类型的父类

反射提供的是runtime阶段获取类的class 实例、方法、属性、注解， 并且能够调用勒的方法的途径。

 

java 多线程

PS：查阅了相关资料和视频，这种类似于计算机内核原理的知识，建议翻阅教科书，了解一下什么是堆，栈，缓冲区等计算机专属词汇，网上很多人讲的不严谨，如果有人想深入大体了解内部机制，强烈安利这个教程 计算机系统基础，有好几季，课程比较长，虽然比较难

并行：指两个或多个事件在同一时刻运行（同时运行）。

并发：指两个或多个事件在同一个时间间隔内发生。

 

线程与进程两者的关系图，推荐看这个图，比较严谨：

https://blog.csdn.net/weixin_41490593/article/details/90704559

 

多线程编程： 

Java中线程有四种创建方式：

l  继承Thread类

l  实现Runnable接口

l  实现Callable接口

l  线程池

前三种方法相应的资料很多，这里仅仅粗略赘述线程池：

/*
java.util.concurrent.ExecutorService  线程池接口

线程池：容器 -- > 集合框架( ArrayList, HashSet, LinkedList<Thread>, HashMap )

接口： 

static ExecutorService newFixedThreadPool(int nThreads)  创建一个可重用固定线程数的线程池

ExecutorService 接口，返回的是ExecutorService接口的实现类对象，可用ExecutorService接口接收（面向接口编程）

submit() 执行线程 线程池会一直开启，使用完了线程，会自动吧线程归还给线程池，线程可以继续执行。

shutdown() 关闭执行， 如果已经执行了此方法，如果重新 使用 submit 方法， 会报错 。



线程池的使用步骤：

1、使用线程池的工厂类 Executors 里面提供的 newFixedThreadPool 生产一个指定线程池数量的线程池

2、创建一个类，实现 Runnable 接口，重写 run 方法，设置线程任务

3、调用ExecutorService 中的方法 submit ，传递线程任务（实现类）， 开启线程， 执行 run 方法

4、调用ExecutorService 中的方法 shutdown ，销毁线程池

*/

进程间协作：

wait ： 是object 类中的一个方法，当前线程释放自己的锁标记，让出CPU资源，当前的线程进入到等待队列中

notify： 是object 类中的一个方法，唤醒等待队列中的一个进程，使这个线程进入锁池

notifyAll ： 唤醒等待队列中的等待当前对象的所有线程，并使这些线程进入锁池

java线程同步机制：

锁，通俗地讲就是告诉其他的线程，这里的鱼塘我承包了，等我解锁你再用

同步锁： 多个线程看到的锁， 需要是同一把锁。

静态方法：同步锁就是类锁，  当前类.class  属性  --> class 文件对象，这一点涉及到 java反射，静态方法优先于对象。

非静态方法： 同步锁 是 this，this 是在创建对象之后产生的。

Runnable r = () -> {
	while(TicketCenter.restCount > 0 ) {
//				synchronized ("") {
		synchronized (Generic.class) {
			if (TicketCenter.restCount <= 0) {
				return ;
			}
			System.out.println("当前运行的进程 ：  " + Thread.currentThread().getName() + "  " + --Center.restCount);
		}
	}
};


Thread t1 = new Thread(r, "thread - 1");
Thread t2 = new Thread(r, "thread - 2");
Thread t3 = new Thread(r, "thread - 3");
Thread t4 = new Thread(r, "thread - 4");

t1.start();
t2.start();
t3.start();
t4.start();

class Center {
    public static int restCount = 100;

}

// 如果一个方法需要执行同步操作，直接加入 synchronize 关键字

 

// 同步方法
private synchronized static void funControl() {
//		synchronized (Generic.class) {
		if (TicketCenter.restCount <= 0) {
			return ;
			
		}
		System.out.println("当前运行的进程 ：  " + Thread.currentThread().getName() + "  " + --TicketCenter.restCount);
//		}
}

  

显式锁 : ReentrantLock  重入锁

当接触临界区时 ReentrantLock 是在 Lock 接口实现的。临界资源由 lock() 和 unlock() 组成。lock() 就是让当前工作进程进入资源，然后使其他的试图进入临界资源的进程阻塞。

ReentrantLock 能够让进程不止一次的进入资源。当这个进程第一次进入内存的时候，有一个计数器记为1，在解锁之前，一个进程又进入时，计数器递增1，每一次unlock() 时，计数器递减1。当计数器为0时，资源被解锁。

Reentrant Locks 可重入锁还提供一个公平性参数，通过该参数，锁将遵守锁请求的顺序，即在线程解锁资源后，锁将转到等待时间最长的线程。此公平模式是通过将true传递给锁的构造函数来设置的。

/*
 * 实例化一个锁对象
 */
ReentrantLock lock = new ReentrantLock();

Runnable r = () -> {
	while(TicketCenter.restCount > 0 ) {
		// 临界资源上锁
		lock.lock();
		
		if (TicketCenter.restCount <= 0) {
			return ;
		}
		System.out.println("当前运行的进程 ：  " + Thread.currentThread().getName());
		// 解锁
		lock.unlock();
	}
};

public void some_method() 
{ 
        reentrantlock.lock(); 
        try
        { 
            //Do some work 
        } 
        catch(Exception e) 
        { 
            e.printStackTrace(); 
        } 
        finally
        { 
            reentrantlock.unlock(); 
        } 
          
}

// volatile关键字 以及 CAS与原子变量使用的不多，这里就不再赘述了。