Java学习-Thread

概述

线程是依赖进程而存在的。

进程：就是 一个个正在运行的程序，是系统进行资源分配和调用的独立单位。每一个进程都有它自己的内存空间和系统资源。

多进程有什么意义？

单进程的计算机只能做一件事件，而我们现在的计算机都可以做多件事情。也就是说现在的计算机都支持多进程的，就可以在一个 时间段内执行多个任务，提高CPU的使用率

单CPU在某一个时间点上只能做一件事情。

什么是线程？

在一个进程内由可以执行多个任务，而这每一个任务都可以看成是一个线程
单线程：程序只有一条执行路径
多线程： 程序有多条执行路径

线程： 是程序的执行单元，执行路径。是程序使用CPU的基本单位

多线程的意义？

多线程的存在，不是提高程序的执行速度。其实是为了提高应用程序的使用率。
程序的执行都是在抢CPU的资源，CPU的执行权。
多个进程抢资源，如果其中一个进程的执行路径多，就会有更高的几率抢到CPU的执行权
不能保证哪一个进程能够在哪个时刻抢到，所以线程执行有随机性。

并行和并发？

前者指逻辑上同时发生，值在某一个时间段内运行多个程序。
后者是物理上的同时发生，值在某一个时间点同时运行多个程序

Thread的创建和基本用法

查看API可知：创建一个新的 线程有两种方法.

继承Thread类

多线程的创建方式一： 继承Thread类

• 定义一个子类MyThread 继承线程类java.lang.Thread，重写run()方法
• 创建MyThread类的对象
• 调用线程对象的start()方法启动线程（启动后还是执行run方法的）
• 优点： 编码简单
• 缺点：线程类已经继承了Thread，无法继承其他类，不利于功能的扩展。

public class MyThread extends Thread {

	@Override
	public void run() {
		// TODO Auto-generated method stub
		
		for (int i = 0; i < 10; i++) {
			System.out.println("currentThread=====" + currentThread().getName() + "======" + i);
		}
	}
}

//测试代码
MyThread  myThread = new MyThread();
MyThread myThread2 = new MyThread();
		/*
		 * start() 和 run() 方法有什么区别
		 * run(): 仅仅是封装线程执行的代码，直接被调用，相当于普通方法的调用
		 * start(): 首先启动了线程，然后在由Jvm去调用run方法
		 */
//启动线程
myThread.start();
myThread2.start();	

多线程注意事项：

• 启动线程必须调用start方法，不是调用run方法
  • 直接调用run方法会被当成普通方法执行，此时相当于还是单线程执行
  • 只有调用strat方法才是启动一个新的线程
• 不要把主线程任务放在启动子线程之前
  • 这样主线程一直是先跑完的，相当于一个单线程的效果了

实现Runnable接口

多线程的创建方式二： 实现Runnable接口

1. 定义一个线程任务类MyThread2实现Runnable接口，重写run()方法
2. 创建MyThread2任务对象
3. 把MyThread2任务对象交给Thread处理
4. 调用线程对象的start()方法启动线程

优缺点：

• 优点： 任务类只是实现接口，可以继续继承其他类、实现其他接口，扩展性强
• 缺点：需要多一个Runnable对象

public class MyThread2 implements Runnable {

	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println("currentThread=====" + Thread.currentThread().getName() + "======" + i);
		}
	};
}

//第二种用法：
		MyThread2  myThread = new MyThread2();
		new Thread(myThread).start();
		new Thread(myThread).start();

实现Callable接口

前面两种线程创建方式都存在一个问题

• 假如线程执行完毕后有一些数据需要返回，他们重写的run方法均不能直接返回结果。

怎么解决这个问题？

• JDK5.0 提供了Callable接口和FutureTask类来实现（多线程的第三种创建方式）。
• 这种方式最大的优点： 可以返回线程执行完毕的结果。

步骤：

1. 创建任务对象
   • 定义一个类实现Callable接口，重写call方法，封装要做的事情，和要返回的数据。
   • 把Callable类型的对象封装成FutureTask（线程任务对象）
2. 把线程任务对象交给Tread对象
3. 调用Thread对象的start方法启动线程
4. 线程执行完毕、通过FutureTask对象的get方法去获取线程任务执行的结果

Thread的常用方法

• void setPriority(int newPriority)：更改此线程的优先级。

  • 线程默认的优先级是 NORM_PRIORITY(5)；
  • IllegalArgumentException - 如果优先级不在 MIN_PRIORITY（1）到 MAX_PRIORITY （10）会抛出此异常。

• 线程优先级高仅仅代表线程获取的CPU时间几率高。

• void join()：等待这个线程死亡。等这个线程执行完成在执行下面的代码

• public void interrupt()： 中断这个线程，抛出一个异常InterruptedException 。

线程的生命周期

线程的生命周期：

• 也就是现成从生到死的过程中，经历的各种状态及状态结构
• 理解线程这些状态有利于提升开发编程的理解能力

线程的状态

• java总共定义了6种状态
• 6总状态都定义在Threa类的内部枚举类中
  

线程的6中状态：

• 新建： 创建线程对象
• 就绪：有执行资格，但是没有执行权
• 运行： 有执行资格，有执行权；
  • 阻塞： 由于一些操作让该线程处于了该状态，没有执行资格，没有执行权，而另一些操作可以把它激活，激活后处于就绪状态
• 死亡：线程对象编程垃圾，等待被回收

• CPU的每一次执行必须是一个原子性（最简单基本，不能拆分）的操作

多线程中的同步

线程同步： 解决现成安全问题的方案
线程同步的思想：让多个线程实现先后依次访问共享资源，这样就解决了安全问题。

synchorized（同步代码块）

作用：把访问共享资源的核心代码给上锁，以此保证线程安全。

原理：每次只允许一个线程加锁后进入，执行完毕后自动解锁，其它线程才可以进来执行。
注意：对于当前同时执行的线程来说，同步锁必须是同一把（同一个对象），否则会出bug

• 使用synchorized关键字加锁 来解决 多线程操作出现的数据同时操作的问题，示例 ： 卖票

/*
 *  同步代码块：
 * 		synchronized(对象){
 * 			需要同步的代码;
 * 		}
 * 
 * 		A:对象是什么呢?
 * 			我们可以随便创建一个对象试试。
 * 		B:需要同步的代码是哪些呢?
 * 			把多条语句操作共享数据的代码的部分给包起来
 * 
 * 		注意：
 * 			同步可以解决安全问题的根本原因就在那个对象上。该对象如同锁的功能。
 * 			多个线程必须是同一把锁。
 */
@Override
	public void run() {
		while (true) {
			synchronized (this) {
				if (tickes > 0) {
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName()
							+ "正在出售第" + (tickes--) + "张票");
				}
			}
		}
	}

• 同步的特点

  • 多个线程
  • 多个线程使用同一个锁对象

• 同步的好处：

  • 同步的出现解决了多线程的安全问题

• 同步的弊端：

  • 当线程相当多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率

• 静态方法及锁对象？（同步方法也可能是静态方法）

  • 静态方法的锁对象是 类的字节码文件对象（也就是class对象）
    

锁对象的使用规范

• 建议使用共享资源作为锁对象，对于实例方法建议使用this作为锁对象。
• 对于静态方法建议使用字节码（类名.class）对象作为锁对象

同步方法

• 由同步关键字synchorized 引出同步方法：

同步方法的底层原理

• 同步方法其实底层又有隐私的锁对象，只是锁的范围是整个方法代码。
• 如果方法是实例方法： 同步方法默认用this作为锁对象
• 如果方法是静态方法：同步方法默认用类名.class作为的锁对象。

//声明一个同步方法，同步方法的锁对象是this 当前对象
	private synchronized void salePiao() {
		if (tickes > 0) {
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()
					+ "正在出售第" + (tickes--) + "张票");
		}
	}

Lock

• Lock实现提供比使用synchronized方法和语句可以获得的更广泛的锁定操作。 它们允许更灵活的结构化，可能具有完全不同的属性，并且可以支持多个相关联的对象Condition 。

• lock是一个接口，使用其子类ReentrantLock来构建Lock锁对象

• lock(): 获得锁

• unlock(): 释放锁

//创建一个锁对象
	private Lock tempLock =  new ReentrantLock();
public void run() {
		while (true) {
			//使用Lock对象来解决

			tempLock.lock();
			if (tickes > 0) {
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName() + "正在出售第" + (tickes--) + "张票");
			}
			
			tempLock.unlock();
		}
	}

区别：

• 范围上： 同步代码锁的范围更小，同步方法锁的范围更大
• 可读性： 同步方法更好

死锁问题

同步： 效率低，如果出现了同步嵌套，就容易产生死锁问题
死锁： 是指两个或则两个以上线程执行过程中，因争夺资源产生一种互相等待的现象

同步代码块的嵌套案例：

public class DieThread extends Thread {

	private boolean flag = true;
	
	public DieThread(boolean flag) {
		super();
		this.flag = flag;
	}
	
	@Override
	public void run() {
		// TODO Auto-generated method stub
	
		if (flag) {
			synchronized (MyLock.objA) {
				System.out.println("if objA");
				synchronized (MyLock.objA) {
					System.out.println("else objcB");
				}
			}
		} else {
			synchronized (MyLock.objB) {
				System.out.println("else objB");
				
				synchronized (MyLock.objA) {
					System.out.println("if objA");
				}
			}
		}
	
	}
	
}

线程之间的通讯

不同种类的线程针对同一个资源的操作

• 等待唤醒机制
  Object类提供了三个方法：
  void wait()：导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法。
  void notify()：唤醒正在等待对象监视器的单个线程。
  void notifyAll()：唤醒正在等待对象监视器的所有线程。

上述方法应该使用当前同步锁对象进行调用

为什么这些方法不定义在Thread类中了？
这些方法的调用必须通过锁对象调用，而我们刚才使用的锁对象是任意对象。所以这些方法必须定义在Object中。

一个生产者和消费者的实例：
生产者： 如果有则不需要生产，等待，然后通知消费者 消费，如果没有则生产
消费者：如果有则直接消费，消费完之后通知生产者生产，如果没有则进入等待状态

/*
 * 模拟线程间的通讯
 * Student类
 * 设置类(SetStudent)
 * 获取类（GetStudent）
 * 测试类
 */
public class StudentDemo {

	public static void main(String[] args) {
		
		Student student = new Student();
		
		SetStudent setStudent = new SetStudent(student);
		GetStudent getStudent = new GetStudent(student);
		
		Thread t1 = new Thread(setStudent);
		Thread t2 = new Thread(getStudent);
		
		t1.start();
		t2.start();
	}
}


//Student类
public class Student {

	int age;
	String name;
	
	//默认是没有  有： true  没有 flase
	boolean flag;
}

// 设置信息类（生产者）
public class SetStudent implements Runnable {

	private Student s;
	private int x;
	public SetStudent(Student s) {
		this.s = s;
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		while (true) {
			synchronized (s) {
				if (s.flag) {
					try {
						s.wait();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				
				if (x % 2 == 0) {
					s.age = 22;
					s.name = "Zhansan";
				} else {
					s.age = 33;
					s.name = "lisi";
				}
				
				x++;
				
			
				//改变
				s.flag = true;
				s.notify();
						
			}
		}
		
	}

}


//获取信息（消费者）
public class GetStudent implements Runnable {

	private Student s;
	public GetStudent(Student s) {
		this.s = s;
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		while (true) {
			synchronized (s) {
				
				if (!s.flag) {
					try {
						s.wait();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				
				System.out.println(s.name + "=====" + s.age);	
				
				
				s.flag = false;
				s.notify();
			}
		}
	}

}


// 优化最终版代码
//把Student的成员变量给私有了。把设置和获取的操作给封装成了功能，并加了同步；设置或者获取的线程里面只调用方法即可
//优化代码如下
//Student
public class Student {

	private int age;
	private String name;
	
	//默认是没有  有： true  没有 flase
	private boolean flag;
	
	public synchronized void set(int age, String name) {
		if (this.flag) {
			try {
				wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		
		this.name = name;
		this.age = age;
		
		//修改标记
		this.flag = true;
		this.notify();
	}
	
	public synchronized void get() {
		if (!this.flag) {
			try {
				wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		
		System.out.println(name + "=====" + age);
		
		this.flag = false;
		this.notify();
	}
}

//SetStudent
public class SetStudent implements Runnable {

	private Student s;
	private int x;
	public SetStudent(Student s) {
		this.s = s;
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		while (true) {
				if (x % 2 == 0) {
					s.set(22, "Zhansan");
				} else {
					s.set(33, "lisi");
				}
				
				x++;
		}
		
	}

}

//GetStudent

public class GetStudent implements Runnable {

	private Student s;
	public GetStudent(Student s) {
		this.s = s;
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		while (true) {
				s.get();	
			}
		}
	

}

• 线程的状态转换图和常见执行情况
  

线程组（ThreadGroup）

线程组代表一组线程。 此外，线程组还可以包括其他线程组。 线程组形成一个树，除了初始线程组之外，每个线程组都有一个父进程。
允许线程访问有关其线程组的信息，但不能访问有关其线程组的父线程组或任何其他线程组的信息。

它可以对一批线程进行分类管理，Java允许程序直接对线程组进行控制
线程默认情况下属于main线程组，默认情况下，所有线程都属于同一个组

使用ThreadGroup 来创建线程组对象，其中一些用法参考API

线程池

什么是线程池？

• 线程池就是一个可以复用线程的技术

不使用线程池的问题

• 用户每发起一个请求，后台就需要创建一个新线程来处理，下次新任务来了肯定又要创建新线程处理的，而创建新线程的开销很大的，并且请求过多时，肯定会产生大量的线程出来，这样会严重影响系统的新能。

程序启动一个新的线程成本是比较高的，因为它涉及到要与操作系统进行交互。而使用线程池可以很好的提高性能，尤其当线程要创建大量生存期很短的线程时，更应该考虑使用线程池。

线程池的每一个线程代码结束后，并不会死亡，而是回到线程池中成为空闲状态，等待下一个对象来使用

谁代表线程池？

• JDK5.0起提供了代表线程池的接口：ExecutorService

如何得到线程池对象？

• 方式一：使用ExecutorService的实现类ThreadPoolExecutor自创建一个线程池对象。
  
• 方式二：使用Executors（线程池的工具类）调用方法返回不同特点的线程池对象。

ThreadPoolExcutor 构造器

线程池的注意事项

• 临时线程什么时候创建?： 新任务提交时发现核心线程都在忙，任务队列也满了，并且还可以创建临时线程，此时才会创建临时线程。
• 什么时候才会开始拒绝新任务?： 核心线程和临时线程都在忙，任务队列也满了，新的任务过来的时候才会开始拒绝任务

ExecutorService的常用方法

新任务拒绝策略：

线程池的基本用法(Executor)

ExecutorService： 该对象表示一个线程池，可以执行Runnable对象或者Callable对象代表的线程。它提供了如下方法

Future<?>	submit(Runnable task)：提交一个可运行的任务执行，并返回一个表示该任务的未来。
<T> Future<T>	submit(Runnable task, T result)：提交一个可运行的任务执行，并返回一个表示该任务的未来。

注意：这些方法的底层，都是通过线程池的实现类ThreadPoolExcutor创建的线程池对象

Excutors可能存在的风险：

• 大型并发系统环境中使用Excutors如果不注意可能会出现系统风险。
  

• 案例演示：

  • 创建线程池对象
  • 创建Runnable实例
  • 提交Runnable实例
  • 关闭线程池

//创建一个线程池对象，控制需要创建几个线程
		ExecutorService poolExecutorService = Executors.newFixedThreadPool(2);
		
		//往线程功池中添加任务
		poolExecutorService.submit(new MyRunnable());
		poolExecutorService.submit(new MyRunnable());
		
		//线程任务执行完成之后，在此回到线程池等待新的对象使用， 这里我们需要关闭线程池
		poolExecutorService.shutdown();

具体一些其他线程池的方法使用，可以参照API文档

使用Callable来实现线程池

首先创建一个Callable实现的线程

import java.util.concurrent.Callable;

/*
 * 该接口的泛型 代表的是call（）方法的返回值
 */
public class MyCallable implements Callable<Object> {

	@Override
	public Object call() throws Exception {
		// TODO Auto-generated method stub
		
		for (int i = 0; i < 100; i++) {
			System.out.println(Thread.currentThread().getName() + "-------" + i);
		}
		
		return null;
	}
}

线程池的实现代码：

public class ExecutorsDemo {
	
	public static void main(String[] args) {
		
		//创建一个线程池对象，控制需要创建几个线程
		ExecutorService poolExecutorService = Executors.newFixedThreadPool(2);
		
		//往线程功池中添加任务
		poolExecutorService.submit(new MyCallable());
		poolExecutorService.submit(new MyCallable());
		
		//线程任务执行完成之后，在此回到线程池等待新的对象使用， 这里我们需要关闭线程池
		poolExecutorService.shutdown();
	}
}

Callable可以算是线程的第三种实现方法，和Runnable接口实现方式差不多，不同的是Callable可以带返回值，然后具有一定的局限性，依赖于线程池来实现。

• 使用Callable来简单实现一个求和的案例

import java.util.concurrent.Callable;

/*
 * 使用Callable是显示求和 计算
 */
 //创建一个Callable类
public class MyCallable implements Callable<Integer> {

	private int endCount;
	public MyCallable(int count) {
		this.endCount = count;
	}
	@Override
	public Integer call() throws Exception {
		// TODO Auto-generated method stub
		int sum = 0;
		for (int i = 1; i <= this.endCount; i++) {
			sum += i;
		}
		
		return sum;
	}
}

// 测试
public class ExecutorsDemo {
	
	public static void main(String[] args) {
		
		//创建一个线程池对象，控制需要创建几个线程
		ExecutorService poolExecutorService = Executors.newFixedThreadPool(2);
		
		//往线程功池中添加任务
		Future<Integer> future =  poolExecutorService.submit(new MyCallable(100));
		Future<Integer> future2 = poolExecutorService.submit(new MyCallable(200));
		
		try {
			System.out.println(future.get());
			System.out.println(future2.get());
		} catch (InterruptedException | ExecutionException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		
		//线程任务执行完成之后，在此回到线程池等待新的对象使用， 这里我们需要关闭线程池
		poolExecutorService.shutdown();
	}
}

匿名内部类的方式实现多线程

匿名内部类可以帮我们省去实现类的定义，但是 一一方面匿名内部类的语法确实太复杂了

匿名内部类的实现方式：
new 类名或则接口名（）{
重写方法；
}；

//第一种方式，使用匿名内部类的方式实现
		new Thread() {
			@Override
			public void run() {
				// TODO Auto-generated method stub
				for (int i = 0; i < 10; i++) {
					System.out.println(Thread.currentThread().getName() + "---------" + i);
				}
			}
		}.start();
		
		
		//第二种方式 实现Runnable接口 使用匿名内部类的方式来实现
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				// TODO Auto-generated method stub
				for (int i = 0; i < 10; i++) {
					System.out.println(Thread.currentThread().getName() + "---------" + i);
				}
			}
		}) {}.start();// {}这个大括号不写也可以
		
		
		//更复杂
		new Thread(new Runnable() {

			@Override
			public void run() {
				// TODO Auto-generated method stub
				for (int i = 0; i < 10; i++) {
					System.out.println("hello" + "---------" + i);
				}
			}
		}) {
		//实际走的是这里的run方法
			@Override
			public void run() {
				// TODO Auto-generated method stub
				for (int i = 0; i < 10; i++) {
					System.out.println("world" + "---------" + i);
				}
			}

		}.start();
//这种方式：接口中实现了run（）方法， 子类对象中又实现了run（）方法  ，不会报错， 但是实际走的是子类对象中国的run方法 ，也就是打印world里面的内容 

定时器

定时器可用于调度多个定时器任务以后台线程的方式执行。在Java中可以通过Timer和TimerTask类来实现定义调度的功能

线程调度任务以供将来在后台线程中执行的功能。 任务可以安排一次执行，或定期重复执行。

定时器中的一些常用方法：

void	cancel()：终止此计时器，丢弃任何当前计划的任务。
void	schedule(TimerTask task, Date time)：在指定的时间安排指定的任务执行。
void	schedule(TimerTask task, Date firstTime, long period)：从指定 的时间开始 ，对指定的任务执行重复的 固定延迟执行 。
void	schedule(TimerTask task, long delay)：在指定的延迟之后安排指定的任务执行。
void	schedule(TimerTask task, long delay, long period)：在指定 的延迟之后开始 ，重新执行 固定延迟执行的指定任务。

演示实例：

/*
 * 可以让我们在指定的时间内做某件事激情，还可以重复的做某件事情
 * 依赖 Timer和TimerTask
 * Timer：定时器
 * TimerTask：任务
 */
public class TimerDemo {

	public static void main(String[] args) {
		System.out.println("主线程=====" + Thread.currentThread().getName());
		//创建一个定时器
		Timer timer = new Timer();
		//定时器需要执行的任务
		timer.schedule(new MyTask(timer), 2000);
		
	}
}

class MyTask extends TimerTask {

	private Timer timer;
	public MyTask( Timer timer) {
		this.timer = timer;
	}
	
	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("定时器执行任务-----" + Thread.currentThread().getName());
		
		//定时器执行完任务后，并不会自动停止，需要手动停止
		this.timer.cancel();
	}
	
}

Lambda的表达式(JDK8新特性)

如何使用代码来实现Lambda表达式：

//1.第一种使用匿名内部类的方式实现多线程
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				// TODO Auto-generated method stub
				System.out.println("创建了新的线程====" + Thread.currentThread().getName());
			}
		}).start();
		
		//2.使用Lambda的表达式来实现多线程的方式
		/*
			（参数列表）-> {重写方法的方法体}
			(): 方法的参数列表，如果参数就是：（）
			->  把参数列表传递给后面的方法体
			{} : 重写方法的方法体
		*/
		new Thread(() -> System.out.println("创建了新的线程====" + Thread.currentThread().getName())).start();
		new Thread(() -> 
			{
				System.out.println("创建了新的线程====" + Thread.currentThread().getName());
			}
		).start();

Lambda标准格式（无参返回）

public interface Cook {

	public void markFood();
}

//定义一个传递参数是Cook接口的方法
public static void invokCook(Cook cook) {
		cook.markFood();
	}

//测试Lambda
		invokCook(new Cook() {
			
			@Override
			public void markFood() {
				// TODO Auto-generated method stub
				System.out.println("匿名内部类实现");
			}
		});
		
		invokCook(() -> {
			System.out.println("Lambdas实现");
		});

Lambda表达式有参数有返回值练习

//测试
		
		Person[] persons = {new Person("zhansan", 22), 
		                    new Person("lishi", 17),
		                    new Person("wangwu", 19)};
		//使用匿名内部类方式进行排序
//		Arrays.parallelSort(persons, new Comparator<Person>() {
//			@Override
//			public int compare(Person o1, Person o2) {
//				// TODO Auto-generated method stub
//				return o1.getAge() - o2.getAge();
//			}
//		});
		
		//使用Lambda表示式来实现
		Arrays.sort(persons, (Person o1, Person o2) ->{
			return o1.getAge() - o2.getAge();
		});
		
		
		for (Person person : persons) {
			System.out.println(person);
		}

	}

自定义接口实现有参数有返回值

public interface Calculate {

	int calculate(int a, int b);
}

public static void main(String[] args) {
		
		
		int sum = calculate(10, 30, (int a, int b) -> {
			return a+b;
		});
		
		System.out.println("sum === " + sum);
	}
	
	
	public static int calculate(int a, int b, Calculate calculate) {
		int result = calculate.calculate(a, b);
		
		return result;
	}

Lambda的省略格式

• Lambda表达式，是可以推到，可以省略，凡是根据上下文推到出的内容，都可以省略

  • （参数列表）： 括号中的参数数据类型可以省略不写
  • （参数列表）： 括号中的参数如果只有一个，那么类型和括号都可以省略
  • 方法体： 如果方法体只有一行，无论是否有返回值，都可以省略（{},return，分号）
    • 注意：如果要省略， 这个三个（{},return，分号）必须一起省略

• 使用前提：

  • 使用Lambda必须要有接口，且接口中有且只有一个抽象方法。无论是JDK的内置的Runnable、Comparator接口还是自定义的接口,只有当接口中的抽象方法存在且唯一时,才可以使用.
  • 使用Lambad必须具有上下文推断；也就是方法的参数或局部变量类型必须为Lambda对应的接口类型,才能使用Lambda作为该接口的实例。

备注： 有且仅有一个抽象方法的接口，被称为函数式接口

多线程中常见面试知识点

• 多线程有几种实现方案，分别是哪几种？

  • 两种： 1.继承Thread类； 2。实现Runnable接口
  • 扩展一种： 实现Callable接口，这个得和线程池结合。

• 同步有几种方式，分别是什么？

  • 两种
  • 同步代码块
  • 同步方法

• 启动一个线程是run()还是start()？ 他们的区别？

  • start()
  • run(): 封装了线程执行的代码，直接调用相当于普通方法的调用
  • start(): 首先启动了线程，然后由JVM自动调用线程中的run()

• sleep()和wait()方法的区别

  • sleep： 必须制定时间。不释放锁。
  • wait(): 可以不指定时间，也可以制定时间； 释放锁

• 为什么wait()、notify()、nitifyAll()、等方法都定义在Object类中？

  • 因为这些方法的调用都是依赖于锁对象，而同步代码块中的锁对象是任意锁。而Object代表任意对象，所以，定义在Object这里面.

• 悲观锁和乐观锁的区别？

  • 悲观锁： 一开始就加锁 ， 每次只能一个线程进入
  • 乐观锁： 一开始不上锁，认为没有问题，大家一起跑，等出现线程安全的问题时候，才开始控制，线程安全，性能较好（例如：整数修改的乐观锁，原子类实现）

扩展知识（设计原则和设计模式）

设计原则

• 单一职责原则

  • 其实就是开发人员经常说的“高内聚，低耦合”
  • 也就是说每个类应该只有一个职责，对外只能提供一种功能，而引起类变化的原因应该也只有一个。在设计模式中，所有的设计模式都遵循着一原则

• 开闭原则

  • 核心思想：一个对象对扩展开放，对修改关闭。
  • 对类的代码是通过增加进行的，而不是修改现有代码

• 里氏替换原则

  • 核心思想：在任何父类出现的地方都可以用它的子类来替代，也就是同一个继承体系中的对象应该有共同的行为特征

• 依赖注入原则

  • 核心思想: 要依赖于抽象，不要依赖于具体实现，为了实现这一原则，要求我们在编程的时候针对抽象类或则接口编程，而不是针对具体的实现编程

• 接口分离原则

  • 核心思想： 不应该强迫程序依赖它们不需要使用的方法，也就是一个接口不需要提供太多的行为，一个接口应该只提供一种对外的功能，不应该把所有的操作都封装到一个接口中。

• 迪米特原则

  • 核心思想： 一个对象应当对其他对象尽可能少的了解，也就是降低各个对象之间的耦合，提高系统的可维护性。在模块之间应该只通过接口编程，而不理会模块的内部工作原理。

单利模式

• 单利模式的实现

  • 单利模式就是咬确保类在内存中只有一个对象，该实例必须自动创建，并且对外提供 。

• 如何保证内存中只有一个对象？

  • 把构造方法私有
  • 把成员位置通过自己创建一个对象
  • 通过一个公共的方法提供访问

实例：

public class Student {

	//1. 把构造私有化
	private Student() {
		
	}
	
	//创建一个静态对象
	// private static Student shareManagerStudent =  new Student(); 进来直接加载对象，这种不会出现问题 开发使用这种
	private static Student shareManagerStudent;
	
	
	/*
	 * 创建一个静态方法 得到对象
	 * 为了防止多线程出现的问题 可以加上 synchorized 同步
	 */
	public synchronized static Student shareManager() {
		if (shareManagerStudent == null) {
		//多线程中可能会出现问题
			shareManagerStudent = new Student();
		}
		
		return shareManagerStudent;
	}
}

//测试
Student student = Student.shareManager();
Student student2 = Student.shareManager();
		
System.out.println(student==student2);