一、多线程
1、线程和进程的区别
进程是操作系统资源分配的基本单位,而线程是处理器任务调度和执行的基本单位, 一个进程可以运行多个线程
多进程:操作系统中同时运行的多个程序
多线程:在同一个进程中同时运行的多个任务
2、创建多线程的四种方式
Runnable和Callable是一个函数式接口:函数式接口是一个只包含有一个抽象方法的接口,可以用lambda表达式
第一种方法 继承Thread类:
class MyThread extends Thread{
@Override
public void run() {
System.out.println("线程1");
}
}
MyThread thread1 = new MyThread();
第二种方法 实现Runnable接口:
class MyRunnable implements Runnable{
@Override
public void run() {
System.out.println("线程1");
}
}
MyRunnable r = new MyRunnable;
new Thread(r).start;
// 或者可以用lambda表达式
new Thread(() -> {
System.out.println("线程1");
}).start;
第三种方法 实现Callable接口,结合 FutureTask:
class MyCallable implements Callable<String>{
@Override
public String call() throws Exception {
return "Result from MyCallable";
}
}
MyCallable myCallable = new MyCallable();
FutureTask<String> futureTask = new FutureTask<>(myCallable);
Thread thread = new Thread(futureTask);
thread.start();
// 接收返回值
String result = futureTask.get();
第四种方法 使用线程池 ExecutorService:
ExecutorService executorService = Executors.newFixedThreadPool(5)
3、集合中的线程安全
ArrayList,HashSet, HashMap都不是线程安全的 如果多个线程同时对这些集合进行操作,可能会导致数据不一致、丢失更新等问题
要解决这些集合的线程安全问题,可以采取以下几种常见的方法:
使用线程安全的集合类
:ArrayList 替代类 Vector,HashMap 替代类 HashTable(这两个都是线程安全的,但效率不高)通过 Collections 类的同步包装方法
:可以使用 Collections.synchronizedList(new ArrayList<>()) 来获取线程安全的 ArrayList
对于HashSet和HashMap,也有相应的同步包装方法(但是效率也不高)使用并发集合类
: List 替代类 CopyOnWriteArrayList, Set 替代类 CopyOnWriteArraySet, Map 替代类 ConcurrentHashMap(这都是线程安全的,而且效率也高)
二、设计模式
设计模式:代码在编写的时候总有一些规律,这些规律在总结之后,变成了设计者模式
1、单例模式
单例模式有两种 一种是饿汉模式 一种是懒汉模式
饿汉模式:在类加载时就创建实例,因为实例在类加载时就已经创建好,所以线程安全
class Girl{
private static Girl girl = new Girl();
// 无参的构造方法
private Girl(){
System.out.println("我是一个女孩");
}
public static Girl creatGirl(){
return girl;
}
}
public class code5 {
public static void main(String[] args) {
Girl girl1 = Girl.creatGirl();
Girl girl2 = Girl.creatGirl();
System.out.println(girl1==girl2);
}
}
// 控制台输出:我是一个女孩
// true
懒汉模式:在第一次使用实例时才创建实例,由于不是在类加载时创建实例,存在线程安全问题
class Boy{ private static Boy boy = null;
private Boy(){
System.out.println("我是一个男孩");
}
// 如果有多个线程同时调用这个方法,偶尔会出现对象被创建多次的情况(所以线程不安全),需要添加一个锁
public synchronized static Boy creatBoy(){
if (boy == null){
boy = new Boy();
}
return boy;
}
}
public class code5 {
public static void main(String[] args) {
Boy boy1 = Boy.creatBoy();
Boy boy2 = Boy.creatBoy();
System.out.println(boy1 == boy2);
}
}
// 控制台输出:我是一个男孩
// true
2、装饰者模式(IO流 缓冲流)
FileReader fileReader = new FileReader(newFile("C:\\Users\\admin\\Desktop\\source.txt"));
BufferedReader br = new BufferedReader(fileReader);
3、适配器模式
一些接口不太适合后面的实现类,需要稍加改进,这个时候我们可以实现一个中间类,完成桥接的或者过渡的作用,这种设计模式,就称之为适配器模式
interface inter{
void eat();
void sleep();
void play();
void run();
void study();
}
// 实现类 (也就是适配器类)
class impl implements inter{
@Override
public void eat() {
}
@Override
public void sleep() {
}
@Override
public void play() {
}
@Override
public void run() {
}
@Override
public void study() {
}
}
class Dog extends impl{
@Override
public void run() {
System.out.println("狗狗奔跑");
}
}
class Person extends impl{
@Override
public void study() {
System.out.println("人在学习");
}
}
public class code6 {
public static void main(String[] args) {
Dog dog = new Dog();
// 接口的多态
inter person = new Person();
dog.run();
person.study();
}
}
// 控制台输出:狗狗奔跑
// 人在学习
4、模板模式
1、需要父子关系
2、将多个子类中共有的方法抽取出来,变为父类的代码(实现)
3、多个子类不同的方法可以在子类中单独实现。
import java.math.BigInteger;
abstract class FuClass{
private String role;
public FuClass(String role) {
this.role = role;
}
public abstract void zuoti();
public void compluteTime(){
long beginTime = System.currentTimeMillis();
zuoti();
long endTime = System.currentTimeMillis();
System.out.println(role+",做题花费了"+(endTime - beginTime));
}
}
class Student2 extends FuClass{
public Student2(String role) {
super(role);
}
@Override
public void zuoti() {
long sum = 0;
for (int i = 0; i < 200000; i++) {
sum += i;
//System.out.println(sum);
}
System.out.println("学生:"+sum);
}
}
class Teacher2 extends FuClass{
public Teacher2(String role) {
super(role);
}
@Override
public void zuoti() {
BigInteger sum = new BigInteger("1");
for (int i = 1; i < 1000; i++) {
sum = sum.multiply(new BigInteger(i+""));
}
System.out.println("老师:"+sum);
}
}
public class Demo11 {
public static void main(String[] args) {
Student2 student2 = new Student2("学生");
student2.compluteTime();
Teacher2 teacher2 = new Teacher2("老师");
teacher2.compluteTime();
}
}