| 文章 | 链接 |
|---|---|
| Java语法 | https://blog.csdn.net/weixin_45606067/article/details/107049186 |
| 一维数组与二维数组、内存解析 | https://blog.csdn.net/weixin_45606067/article/details/107049178 |
| 面向对象（1/3）类和对象 | https://blog.csdn.net/weixin_45606067/article/details/108234276 |
| 面向对象（2/3）封装性、继承性、多态性 | https://blog.csdn.net/weixin_45606067/article/details/108234328 |
| 面向对象（3/3）抽象类、接口、内部类、代码块 | https://blog.csdn.net/weixin_45606067/article/details/108258152 |
| 异常处理 | 待更新 |
| 多线程（1/2） | https://blog.csdn.net/weixin_45606067/article/details/107067785 |
| 多线程（2/2） | https://blog.csdn.net/weixin_45606067/article/details/107067857 |
| 常用类 | https://blog.csdn.net/weixin_45606067/article/details/108283203 |
| 枚举与注解 | 待更新 |
| 集合（1/5）Collection、Iterator、增强for | https://blog.csdn.net/weixin_45606067/article/details/107046876 |
| 集合（2/5）List、ArrayList、LinkedList、Vector的底层源码 | https://blog.csdn.net/weixin_45606067/article/details/107069742 |
| 集合（3/5）set、HashSet、LinkedHashSet、TreeSet的底层源码 | |
| 集合（4/5）Map、HashMap底层原理分析 | https://blog.csdn.net/weixin_45606067/article/details/107042949 |
| 集合（5/5）LinkHashMap、TreeMap、Properties、Collections工具类 | https://blog.csdn.net/weixin_45606067/article/details/107069691 |
| 泛型与File | https://blog.csdn.net/weixin_45606067/article/details/107124099 |
| IO流与网络编程 | https://blog.csdn.net/weixin_45606067/article/details/107143670 |
| 反射机制 | 待更新 |
| Java8新特性 | https://blog.csdn.net/weixin_45606067/article/details/107280823 |
| Java9/10/11新特性 | 待更新 |
程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。
进程(process)是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程:有它自身的产生、存在和消亡的过程。 ------ 生命周期
线程(thread)：进程可进一步细化为线程，是一个程序内部的一条执行路径。
进程可以细化为多个线程。
每个线程，拥有自己独立的：虚拟机栈、程序计数器
多个线程，共享同一个进程中的结构：方法区、堆。
单核CPU：其实是假的多线程，因为在一个时间单元内，也只能执行一个线程的任务。多个线程交替进行。
多核CPU：才能更好的发挥多线程的效率。
一个Java应用程序java.exe,其实至少个线程: main()主线程，gc()垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。
并行：多个cpu同时执行多个任务。
并发：一个cpu（采用时间片）同时执行多个任务。
背景:以单核CPU为例，只使用单个线程先后完成多个任务(调用多个方法)，肯定比用多个线程来完成用的时间更短，为何仍需多线程呢?
多线程程序的优点:
1.提高应用程序的响应。对图形化界面更有意义，可增强用户体验。
2.提高计算机系统CPU的利用率
3.改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改
1.程序需要同时执行两个或多个任务。
2.程序需要实现一些需要等待的任务时，用户输入，文件读写，网络操作，搜索等。
3.需要一些后台运行的程序时。
步骤：
1.创建一个继承于Thread类的子类
2.重写Thread类的run()方法 —> 将此线程执行的操作声明在run()中
3.创建Thread类的子类的对象
4.通过此对象调用start()：①启动当前线程 ②调用当前线程的run()
代码实现：
/*
例子：遍历100以内的所有的偶数
*/
public class ThreadTest {
public static void main(String[] args) {
MyThread myThread = new MyThread();
myThread.start();
//问题一：我们不能通过直接调用run()的方式启动线程。
// myThread.run();
//问题二：在启动一个线程，遍历以内的偶数。不可以还让已经start()的线程去执行，会报IllegalThread
// myThread.start();
//我们需要重新创建一个线程的对象
MyThread myThread2 = new MyThread();
myThread2.start();
}
}
class MyThread extends Thread{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 ==0){
System.out.println(Thread.currentThread().getName()+" "+i);
}
}
}
}
测试Thread中的常用方法：
3.1 调度策略
时间片
抢占式：高优先级的线程抢占CPU
3.2 Java的调度方法
3.3 线程的优先级等级
3.4 涉及的方法
3.5 说明
注意：
线程通信：wait() / notify() / notifyAll()：此三个方法定义在Object类中。
3.6 线程的分类：一种是守护线程，一种是用户线程。
/**
* 创建多线的方式一：通过继承Thread类的方式
* 例子：创建三个窗口卖票，总票数为100张
* 存在线程安全问题，待解决。
*
* @Author: Guohai
* @Date: 2020-06-22 17:14
*/
public class WindowTest {
public static void main(String[] args) {
Window w1 = new Window();
Window w2 = new Window();
Window w3 = new Window();
w1.setName("窗口1");
w2.setName("窗口2");
w3.setName("窗口3");
w1.start();
w2.start();
w3.start();
}
}
class Window extends Thread{
private static int ticket = 100;
@Override
public void run() {
while (true){
if (ticket > 0){
System.out.println(Thread.currentThread().getName() + ":卖票的票号为：" +ticket);
ticket --;
}else {
break;
}
}
}
}
步骤：
1.创建一个实现了Runnable接口的类
2.实现类去实现Runnable中的抽象类：run()
3.创建实现类的对象
4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
5.通过Thread类的对象调用start()
代码实现：
/**
* 创建多线的方式二：实现Runnable接口方式
* 例子：创建三个窗口卖票，总票数为100张
* 存在线程安全问题，待解决。
*/
public class WindowTest1 {
public static void main(String[] args) {
Window1 w = new Window1();
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
class Window1 implements Runnable{
/*
此处不用static修饰的原因，因为上面类中的方法仅仅new了一个类的对象，
所以个Thread对象实际上只是使用了同一个对象的票。
*/
private int ticket = 100;
@Override
public void run() {
while (true){
if (ticket > 0){
System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" +ticket);
ticket --;
}else {
break;
}
}
}
}
开发中：优先选择，实现Runnable接口的方式。
原因：
1.实现的方式没有类的单继承性的局限性。
2.实现的方式更适合处理多个线程有共享数据的情况。
联系：public class Thread implements Runnable
相同点：两种方式都需要重写run() ，将线程执行的逻辑声明在run()中。
使用同步代码块解决实现Runnable方式的线程安全问题。
1.问题：卖票过程中，出现了重票、错票 —> 出现了线程的安全问题
2.问题出现的原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票。
3.如何解决：当一个线程a在操作ticket的时候，其他线程不能参与进来。直到线程a操作完ticket时，其他线程才可以操作ticket。这种情况即使线程a出现了阻塞，也不能被改变。
4.在Java中，我们通过同步机制，来解决线程的安全问题。
方式一：同步代码块
synchronized(同步监视器){
//需要被同步的代码
}
说明：
1.操作共享数据的代码，即为需要被同步的代码。 不能包含代码多了，也不能包含代码少了。
2.共享数据：多个线程共同操作的数据。比如：ticket就是共享数据。
3.同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。
要求：多个线程必须要共用同一个锁。
补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。
在继承Thread类创建多线程的方式中，慎用this充当同步监视器，考虑使用当前类充当同步监视器。
5.同步的方式，解决了线程的安全问题 —> 好处
操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低 —>坏处
代码实现：
/*
例子：创建三个窗口卖票，总票数为100张
*/
public class WindowTest1 {
public static void main(String[] args) {
Window1 w = new Window1();
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
class Window1 implements Runnable{
private int ticket = 100;
Object obj = new Object();
@Override
public void run() {
while (true){
//synchronized (obj) {
synchronized (this){
if (ticket > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
ticket--;
} else {
break;
}
}
}
}
}
使用同步代码块解决继承Thread类的方式的线程安全问题
说明：在继承Thread类创建多线程的方式中，慎用this充当同步监视器。考虑使用当前类充当同步监视器。
代码实现：
/*
例子：创建三个窗口卖票，总票数为100张
*/
public class WindowTest2 {
public static void main(String[] args) {
Window2 w1 = new Window2();
Window2 w2 = new Window2();
Window2 w3 = new Window2();
w1.setName("窗口1");
w2.setName("窗口2");
w3.setName("窗口3");
w1.start();
w2.start();
w3.start();
}
}
class Window2 extends Thread{
private static int ticket = 100;
private static Object obj = new Object();
@Override
public void run() {
while (true){
//synchronized (obj){
synchronized (Window2.class){
//错误的使用
//synchronized (this){
if (ticket > 0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":卖票的票号为：" +ticket);
ticket --;
}else {
break;
}
}
}
}
}
使用同步方法解决实现Runnable方式的线程安全问题。
方式二：同步方法
如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的。
1.同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
2.非静态的同步方法，同步监视器是: this
静态的同步方法，同步监视器是:当前类本身
代码实现：
public class WindowTest3 {
public static void main(String[] args) {
Window3 w = new Window3();
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
class Window3 implements Runnable{
private int ticket = 100;
@Override
public void run() {
while (true){
show();
}
}
private synchronized void show(){//同步监视器：this
if (ticket > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
ticket--;
}
}
}
使用同步方法解决继承Thread类的方式的线程安全问题
代码实现：
/*
例子：创建三个窗口卖票，总票数为100张
*/
public class WindowTest4 {
public static void main(String[] args) {
Window4 w1 = new Window4();
Window4 w2 = new Window4();
Window4 w3 = new Window4();
w1.setName("窗口1");
w2.setName("窗口2");
w3.setName("窗口3");
w1.start();
w2.start();
w3.start();
}
}
class Window4 extends Thread{
private static int ticket = 100;
@Override
public void run() {
while (true){
show();
}
}
private static synchronized void show(){
if (ticket > 0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":卖票的票号为：" +ticket);
ticket --;
}
}
}