Java基础-多线程以及Collection+Map集合接口

阿里云大学课27. Thread类实现多线程

要想实现多线程必须有一个多线程的执行主类。
主类的定义结构：

• 继承一个Thread类
• 【推荐-避免单继局限】实现Runnable、Callable接口

java.lang.Thread 直接继承Thread类并覆写类中的run()方法（至关于线程的主方法）

class MyThread extends Thread {
    //线程主体类
    private String title;
    public MyThread(String title) {
        this.title = title;
    }
    @Override
    public void run() { // 全部的线程今后处开始执行
        for (int x = 0; x < 10; x++) {
            System.out.println(this.title + ", x = " + x);
        }
    }
}

public class Demo {
    public static void main(String[] args) {
        MyThread mt1 = new MyThread("线程A");
        MyThread mt2 = new MyThread("线程B");
        MyThread mt3 = new MyThread("线程C");
        mt1.start(); //错误的启动: mt1.run();
        mt2.start();jichu
        mt3.start(); 
    }
}

只是顺序打印
正确启动多线程的方式应该调用的是Thread类当中的start()方法
多线程启动只有一个方法：public void start()

课28. Runnable 接口实现多线程

Runnable里只有一个run()方法, 和Thread相同，

@FunctionalInterface
public interface Runnable {
    public void run();
}

//利用Runnable 定义线程主体类
class MyThread implements Runnable {
    //线程主体类
    private String title;
    public MyThread(String title) {
        this.title = title;
    }
    @Override
    public void run() { // 全部的线程今后处开始执行
        for (int x = 0; x < 10; x++) {
            System.out.println(this.title + ", x = " + x);
        }
    }
}

public class Demo {
    public static void main(String[] args) {
        MyThread mt1 = new MyThread("线程A");
        MyThread mt2 = new MyThread("线程B");
        MyThread mt3 = new MyThread("线程C");
        new Thread(mt1).start(); //匿名内部类传入一个接口
        new Thread(mt2).start();
        new Thread(mt3).start();
    }
}

Thread与Runnable的区别
public class Thread extends Object implement Runnable
实现Runnable方法会致使无法调用Thread类中的start()方法，稍微拐个弯用Thread的构造方法public Thread(Runnable target)来接收Runnable接口对象，而后再直接调用start()方法

课29 Thread与Runnable的区别

Runnable避免了单继承局限，
Thread类的继承定义形式
public class Thread extends Object implements Runnable
Thread是Runnable接口的子类

@Override
public run() {
    if (target != null) {

线程池：多个线层封装在一块儿进行操做
为何须要线程池？
例子：兄弟们，有个活，3天完成，20我的一块儿干 20我的就是一个线程池

java.util.concurrent从JDK 1.5以后的添加的并发数据包

Interface ExecutorService
Interface ScheduledExecutorService
若是要进行线程池的建立

建立无限大小 线程对象
建立固定大小的线程池
建立定时调度池
```java
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Demo {
public static void main(String[] args) throws Exception {
//建立一个线程池的模型
ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
for (int x = 0; x < 10; x++) {
executorService.submit(() -> {
System.out.println(Thread.currentThread().getName() + "、 x = " + index);
});
}
executorService.shutdown();

使用Object类当中的唤醒与等待机制进行操做
public final void notify() //唤醒第一个等待线程

public final void notifyAll() //

class Data {
    private String title;
    private note;

    private boolean flag = true;

    public synchronized void set(String title, String note) {
        if (this.flag = false) {
            try {
                super.

请解释sleep() 与 wait()的区别
sleep() 是Thread类中定义的方法，到了必定的时间后该休眠的线程能够自动唤醒
wait() 是Object类中定义的方法，若是想要唤醒，必须使用notify()、notifyAll() 才能唤醒

Java的类集之中(java.util包) 当中提供的两个最为重要核心的操做接口： Collection + Map

Collection 与链表相似：每一次进行数据操做的时候只可以对单个的对象进行处理，因此Collection是单个集合保存的最大父接口

Collection接口的定义

public interface <E> extends Iterable<E>

最重要的几个方法：
子接口都有的两个方法
* public boolean add(E)
* public Iterator iterator 取得Iterator

考虑Collection接口的子接口: List(容许重复） Set（不容许重复）

List接口

两个重要的扩充方法:
* public E get(int index) //根据索引取得数据
* public E set(int index, E element) //修改数据
List使用比例能够达到Collection的 80%
线程的同步和死锁，概念很重要

List三个经常使用子类：ArrayList, Vector, LinkedList

全部子类的方法均可以参考接口中的定义，使用形式上相同

对比区别：
ArrayList: 一个针对于List接口的数组操做实现
每个线程对象操做的延迟问题（轮番抢占资源致使）
先作一个简单的程序：实现多个线程卖票的处理

//source: aliyun java学习路线图-高级【课时35】
class MyThread implements Runnable {
    private int ticket = 10; //要卖出的总票数
    
    @Override
    public void run() {
        for (int x = 0; x < 20; x++) {
            if (this.ticket > 0) {
                try
                System.out.println(Thread.currentThread().getName() + "卖票, ticket = " + this.ticket;
            }
        }
    }

    public class Demo {
        public static void main(String[] args) throws Exception {
            System.out.println(Thread.currentThread().getPriority());
        }
    }
}

Set接口集合

TreeSet排序分析

使用TreeSet排序，须要Comparable类的支持，全部属性都须要参与比较

import java.util.LinkedList;
class Person {
    private String

List
AbstractSet -中间的抽象类
HashSet：无序存储
TreeSet: 有序存储

Hash算法

如何解决
1.同步代码块：

• 在方法里面进行拦截，用同步代码块必需要设置一个锁定的对象

1. HashTable

HashMap
请解释HashMap的原理

请解释HashMap与HashTable的区别

Concurrent HashMap

区别	HashMap	HashTable
推出版本	JDK 1.2推出	JDK 1.0推出
性能	异步处理、性能高	同步处理、性能较低
安全性	非线程安全	线程安全
null操做	容许存放null	key 和 value都不容许为空，不然会出现NullPointerException

多考虑HashMap

不是传统的软件开发而是互联网的项目了