Spark-Java Day 19多线程与泛型

1 多线程
1.1 线程间通信
(1) 创建线程是由于操作系统决定，因此顺序不确定，在程序中通过条件控制，让线程执行有顺序的，这个机制------>等待唤醒机制。
(2)等待唤醒机制调用方法
第一个 wait()方法 线程不再活动，不再参与调度（释放锁，需要被唤醒）
第二个notify()/notifyAll()选取通知的wait()线程释放
均为Object类的方法
(3)编写线程间通信例子
1.2 线程其他概念
a 线程生命周期
线程生命周期五种状态：新建(New), 就绪(Runnable), 运行(Running), 阻塞(Blocked),
死亡(Dead).
b 线程阻塞
- 线程调用了sleep()方法，主动放弃所占用的CPU资源；
- 线程试图获取一个同步监视器，但该同步监视器正被其他线程持有；
- 线程执行过程中，同步监视器调用了wait()，让它等待某个通知（notify）；
- 线程执行过程中，同步监视器调用了wait(time)
- 线程执行过程中，遇到了其他线程对象的加塞（join）；
c

public enum State {
	        	NEW,   新建
		        RUNNABLE,  准备就绪
		        BLOCKED,   阻塞
		        WAITING,   不见不散
		        TIMED_WAITING, 过时不候
		        TERMINATED;    终结
	   		 }

1.3 Thread和Runnable区别
1. 适合多个相同的程序代码的线程去共享同一个资源。
2. 可以避免java中的单继承的局限性。
3. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
4. 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。

1.4 释放锁操作
* 当前线程的同步方法、同步代码块执行结束。
* 当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、该方法的继续执行。
* 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致当前线程异常结束。
* 当前线程在同步代码块、同步方法中执行了锁对象的wait()方法，当前线程被挂起，并释放锁。

1.5 死锁
不同的线程分别锁住对方需要的同步监视器对象不释放，都在等待对方先放弃时就形成了线程的死锁。
一旦出现死锁，整个程序既不会发生异常，也不会给出任何提示，只是所有线程处于阻塞状态，无法继续。

1.6 sleep()和wait()方法的区别
- sleep()不释放锁，wait()释放锁
- sleep()自动在指定时间唤醒，wait()可以指定时间也可以使用notify或notifyAll唤醒
- sleep()在Thread类中声明的静态方法，wait方法在Object类中声明

2 泛型
2.1
(1) jdk1.5之后开始出现的新特性。
(2) 使用泛型可以限定集合或者数组放什么类型数据
2.2 泛型解决问题
<自定义类型>:使用大写字母代表自定义类型
<>可以写在类部分或者方法部分
例子：

class Fan<T>{
			    private T a;
			    private T b;

			    public Fan(T a, T b) {
			        int c = (Integer)a;
			        int d = (Integer)b;
			}
Fan<Integer> objectFan = new Fan<Integer>(1,5);
Fan<Double> object = new Fan<Double>(1.0,5.5);

2.3 泛型和泛型接口
(1) 泛型可以在类上和接口上使用

public class TestStudent {
    public static void main(String[] args) {
        Student<String> stringStudent1 = new Student<String>("张三", "优秀");
        Student<Double> stringStudent2 = new Student<Double>("张三", 100.2);
        Student<Character> stringStudent3 = new Student<Character>("张三", 'g');
        System.out.println(stringStudent1.toString());
        System.out.println(stringStudent2.toString());
        System.out.println(stringStudent3.toString());
    }
}

interface Idao<T>{
    public void addTdao(String name);
}

class IdClass implements Idao<String>{
    @Override
    public void addTdao(String name) {

    }
}


class Student<T>{
    private String name;
    private T score;

    public Student(String name, T score) {
        this.name = name;
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", score=" + score +
                '}';
    }
}

2.4 类型变量上限
语法：<T extends 上限类>
<T extends 上限类1 & 上限类2>

 public class TestLimit {
	    public static void main(String[] args) {
	        Limit<Integer> integerLimit = new Limit<>(12);
	//        Limit<String> integerLimit = new Limit<>(12); 错误

	    	}
}

class Limit<T extends Integer>{
    private T a;

    public Limit(T a) {
        this.a = a;
        System.out.println(a);
    }
}

2.5 泛型擦除
泛型只在编译中出现，编译之后没有泛型
2.6 泛型方法
语法：public static void 方法名称(T a, T b) throws Exception{}

public class TestMethod {
    public static void main(String[] args) {
        getScore("good");
        getScore(12);
        getScore('a');
    }

    public static <T> void getScore(T a){
        System.out.println(a);
    }
}

2.6 类型通配符

	public class TestEvery {
    public static void main(String[] args) {
        StudentE<?>[] studentES = new StudentE[3];
        studentES[0] = new StudentE<>("zz","good");
        studentES[1]  = new StudentE<>("zz",'g');
        studentES[2]  = new StudentE<>("zz",100.00);
        for (int i = 0; i < studentES.length; i++) {
            System.out.println("studentES[i].toString() = " + studentES[i].toString());
        }
    }
}
class StudentE<T>{
    private String name;
    private T score;

    public StudentE(String name, T score) {
        this.name = name;
        this.score = score;
    }

    @Override
    public String toString() {
        return "StudentE{" +
                "name=" + name +
                ", score=" + score +
                '}';
    }
}

2.7 类型通配符上限下限
a 上限<? extends 上限类型>
代表接受上限类型或者上限类型的子类型的元素
b 下限<? super 下限类型>
代表接受下限类型或者下线类型的父类型的元素
3 数据结构
数据结构研究数据的逻辑结构和物理结构。
a 多个数据的存储特点
b 多个数据之间的关系体现出来
3.1 常用的数据结构
a 集合
b 线性结构
c 树形结构
d 图形结构
3.2 数组结构特点
a 逻辑结构：线性的
b 物理结构：连续的存储空间
c 一次申请一大段连续的空间，一旦申请到，内存就固定。
d 所有数据存储在这个连续空间中，数组中每一个元素都是一个具体的数据(对象或地址),所有数据紧密排布，不能有间隔。
e 数组查询方便
3.3 链表存储结构特点
a 普通单链表，元素节点和指向下一节点指针。
b 查询不方便，添加效率相对高