线程

面试必备线程题，虽然开发里面对于我这种程序员用的很少

以前一听线程貌似很高大上，其实都一样，程序时理科，不是文科，理解了就好了，如果只靠背，永远都是不行的

      1.程序，进程，线程的关系

         程序：一堆代码（程序和进程就像火车[程序]和列车[进程]一样）

         进程：正在运行的程序，操作系统分配系统的最小单位

         线程：一个进程至少有一个线程

                     一个进程中所有线程共享进程的所有资源

                     就绪，运行，阻塞，死亡（结束）

        2.继承Thread，重写run方法（public void run(){  }）,对象名.start()------进入就绪状态，有权利去获取cpu，不是马上执行

            运行状态----真正执行

            一个线程对象只能start一次，多次会报异常------------java.lang.IllegalThreadStateException

            启动一个线层用start方法，如果用run方法，编译不会报错，但是这样就不是多线程了，会先执行第一个对象的run之后执行第二个对象的run

            Thread.currentThread().getName()----------获取当前现成的名字

       3.实现Runnable接口，Thread t=new Thread(实现Runnable接口的类创建的对象);

                                                 t.start();

          start()方法启动的时候，方法是各自加载一份，谁用谁拿副本去跑，跑的是不同的run方法

          Runnable--多个线程共享一个对象

          Thread类也实现的Runnable接口

    

        4.多进程：同时做多个事情，不一定比一个一个来的快，主要是同时做

            多线程：同时完成多个任务

            t1.start()----

            t2.start()----共分cpu，只能证明t1比t2先进入就绪状态，但是无法知道谁先执行，执行频率也不是一人一次，无法确定（就绪之后的操作无法判断）

            执行时------cpu时间片去判断，相当于cpu给你分了多长时间去处理这个线程，如果期间没有处理完，阻塞

           main方法也是一个线程，但是规定main方法的线程是一定会第一时间执行的

           同时线程是有级别的，级别高的线程更高的去占用cpu时间（导致执行次数多），但是无法保证谁先跑，谁后跑（同时执行，只是尽量给你更多的时间）

         

线程很简单，难的是线程安全，也就是线程里面的数据共享

       首先想的是什么变量会被同时用到，之后就需要给这个资源上锁（也就是同步）

       synchronized（xxx）--1.锁共用的东西--但是必须是引用类型

                                               2.还可以用同步代码块

                                                3.对象锁--所有引用类型---为什么可以作为对象锁----继承Object---提供了一个属性0,1  这个被用了就会从0变成1，用完再改回来，保证只有一个线程

                                                     可以进入同步代码块，或者同步方法，别人想进只有等这个线程执行完才可以，实现了资源的共享

        同步代码块，或者方法用完，也就是导致对象锁释放-----1.里面的方法执行完

                                                                                                           2.运行的时候出异常了

                                                                                                           3.调用wait给自己阻塞了，sleep不可以（阻塞，但是不放锁）

                                                                                                            4.逻辑判断让其停止

          同步方法----用同步代码块括起来的方法-------但是无法指定对象锁了-----默认用当前自己（this）作为对象锁

        

          线程安全----------只有成员变量才用考虑安全（共用），像局部变量一人一份，根本不用考虑安全的问题

                                        1.读读---不考虑

                                         2.读写----考虑--读出来写的中间量--废了--所以需要考虑安全问题----不止写方法需要加同步关键字，读方法也需要----因为锁的是对象不是代码，所以只能

                                                           进入一个同步方法

                                         3.写写----考虑

                          -----------锁的是对象，不是代码，代码无法锁住

          线程通讯--------一个线程告诉另一个线程某些情况------共享一个资源就可以解决这个问题了

 

          wait方法------this.wait()----Object的方法，共享资源是谁用谁的wait，wait会释放对象锁--------所以很容易想象如果这个方法没有上锁，调用wait肯定报错，编译无错误，

           运行时异常，wait（xxx）--xxx秒后进入就绪状态，同时wait（）如果不唤醒会一直睡---------怎么唤醒--------notify（）随机唤醒，notifyAll（）----混淆所有-但是用谁对象

           锁住，用谁notify（）---唤醒之后进入就绪状态

          sleep------阻塞自己，释放cpu，但是不释放对象锁

           Thread.yield--------让出本次cpu控制权，不会释放对象锁

          死锁----不同资源才会出现--A--->B,B---->A  至少两个线程，两个资源，一个人一个，互相等待-----1.同步代码块的嵌套  2.嵌套争取的资源，顺序不一样

      

          对象池------t1+t2+t3-------创建+使用+销毁

                       -------1.最大连接数

                       -------2.最大等待连接数------最大有几个空闲

                      --------3.最大等待时间--------本质wait

 

          联合线程-------------join---A执行完B执行

          守护线程------垃圾回收器----为用户线程服务（不会单独存在，生命周期随用户线程销毁而销毁）

                          ------在就绪前才可以变成守护线程-------b.setDaemon(true)