java设计模式和多线程高并发小结后续继续更新

一、设计模式：
java一共有23中设计模式

二、多线程高并发
熟练掌握api，能够完成并发编程
熟读api源码，掌握其原理
理解java虚拟机内存模型
操作系统对并发的支持  


为什么要学习并发编程：

几乎任何一个应用都是并发的多线程的

并发的优点

发挥多核处理器的强大的能力
建模的简单性
异步事件的简化处理
响应更加灵敏的用户界面


1.找工作

2.了解了并发编程，提高代码的编写能力

3.解决工作中遇到的高并发问题

并发的缺点

安全性问题
活越性问题（多个线程是在抢占cpu，秩序混乱，（饥恶状态）（死锁））
性能问题（多线程并不一定快）
线程安全性问题

创建线程的 多种方式
多线程运行 卖票
线程安全性问题
提出解决方案 synchronized
解决线程安全性问题
synchronized原理
。。。


什么是并发？

java代码最终被翻译成字节码，java虚拟机执行的是字节码指令，最终运行在cpu上

并发是多个线程在一块执行

什么是多线程？

每一个线程就是一个顺序执行流

多线程并不一定是并发

​
1
int a=10;
2
int b=20;
3
int c=a+b;
4
System.out.println()
5
    Java虚拟机从上往下顺序执行（java虚拟机中的寄存器）
6
    垃圾收集器（gc），在后台工作（令一个线程在执行）
7
    java虚拟机内存有两个区域
8
        一个是被线程所供享的（堆和方法区）
9
        一个是被线程所独占的（私有线程存储区）
10
    
​
什么是进程？

一个运行中的程序

进程是资源分配的基本的单位

进程中包含着多个线程，线程共享进程的资源

线程是处理器电镀的基本单位。（线程是轻量级的线程，进程在进行切换的时候会浪费更多的资源）

线程一定会快吗？

迅雷多线程下载为什么快

并不是多线程性能提高了

而是由于下载接口多了，最后进行了合并

使得整体的完成时间减少了。

垃圾收集：！！！有空看看。



线程的状态

初始化（start（））=》就绪态=》运行态=》终止态（Dead（））  



​image.png​



​
1
//先演示下线程之间的状态。
2
public class NewThread implements  Runnable{
3
    @Override
4
    public synchronized void  run() {
5
        while (true){
6
//            System.out.println("自定义的线程运行了");
7
            try {
8
                wait();//等待
9
//                Thread.sleep(100);
10
            } catch (InterruptedException e) {
11
                e.printStackTrace();
12
            }
13
            System.out.println("自定义的线程运行了");
14
        }
15
​
16
​
17
    }
18
​
19
    public static void main(String[] args) {
20
​
21
       NewThread n = new NewThread();
22
        //初始化状态
23
        Thread thread=new Thread(n);//创建了线程，并指定了线程方法
24
​
25
        thread.start();//启动线程
26
        while(true){
27
            synchronized (n){
28
                System.out.println("主线程执行了");
29
                try {
30
                    Thread.sleep(100);
31
                } catch (InterruptedException e) {
32
                    e.printStackTrace();
33
                }
34
                n.notifyAll();//唤醒
35
            }
36
​
37
        }
38
    }
39
​
40
​
41
}
42
​
​
创建线程的多种方式：

继承thread


ThreadGroup  线程组（对线程进行分组）

stackSzie 栈大小（虚拟机课用的）

interrupted（） 中断线程

isinterrupted （）判断是否中断

​
1
​
2
//继承Thread创建线程实现多线程
3
public class Demo1 extends Thread {
4
​
5
    public Demo1(String name) {
6
        super(name);
7
    }
8
​
9
​
10
​
11
    public void run() {
12
        while (!interrupted()){//不可以true
13
            System.out.println(getName() + "线程执行了");
14
        try {
15
            Thread.sleep(200);
16
        } catch (InterruptedException e) {
17
            e.printStackTrace();
18
        }
19
    }
20
​
21
}
22
​
23
​
24
    public static void main(String[] args) {
25
        Demo1 d1=new Demo1("线程1");
26
        Demo1 d2 =new Demo1("线程2");
27
​
28
//        d1.setDaemon(true);//守护线程，支持性线程
29
//        d2.setDaemon(true);//守护线程，支持性线程
30
​
31
        d1.start();
32
        d2.start();
33
​
34
        d1.interrupt();//中断
35
//        try {
36
//            Thread.sleep(2000);//休息两秒钟
37
//        } catch (InterruptedException e) {
38
//            e.printStackTrace();
39
//        }
40
    }
41
}
42
​
​


实现Runnable接口


​
1
//实现Runnable接口实现线程的创建
2
public class Demo2 implements  Runnable{
3
    @Override
4
    public void run() {
5
        while (true){
6
            System.out.println("thread running...");
7
        }
8
    }
9
​
10
    public static void main(String[] args) {
11
​
12
        Thread thread=new Thread(new Demo2());
13
        thread.start();
14
    }
15
​
16
}
​


匿名内部类的方式


​
1
//匿名内部类两种方式
2
public class Demo3 {
3