java语言基础整理

　　　　3）for循环

　　　　4）while循环

　　final finally finalize区别

　　Map

　　　　1)该集合存储键值对，一对一对往里存

　　1）线程和进程

　　　　1、线程

　　　　2、进程和线程的区别

　　　　　　进程是应用程序，线程是一条执行路径

　　　　　　守护线程（即daemon thread），是个服务线程，准确地来说就是服务其他的线程。

重写run方法

　　　　　c.实现callable接口，Callable接口代表一段可以调用并返回结果的代码;Future接口表示异步任务，是还没有完成的任务给出的未来结果。

　　　　　　所以说Callable用于产生结果，Future用于获取结果。

　　　　　d.线程池ThreadPoolExcutor

　　　　　　　　new ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,long keepAliveTime, TimeUnit unit,BlockingQueue workQueue,RejectedExecutionHandler handler)

　　　　　　　　(1)corePoolSize： 线程池维护线程的最少数量 （core : 核心）

　　　　　　　　(2)maximumPoolSize： 线程池维护线程的最大数量

　　　　　　　　(3)keepAliveTime： 线程池维护线程所允许的空闲时间

　　　　　　　　(4)unit： 线程池维护线程所允许的空闲时间的单位

　　　　　　　　(5)workQueue： 线程池所使用的缓冲队列

　　　　　　　　(6)handler： 线程池对拒绝任务的处理策略

　　　　　　思考：说一下 runnable 和 callable 有什么区别？

　　　　　　　　Runnable接口中的run()方法的返回值是void，它做的事情只是纯粹地去执行run()方法中的代码而已；

　　　　　　　　Callable接口中的call()方法是有返回值的，是一个泛型，和Future、FutureTask配合可以用来获取异步执行的结果。

　　　　5、run和start的区别

　　　　　　　每个线程都是通过某个特定Thread对象所对应的方法run()来完成其操作的，方法run()称为线程体。通过调用Thread类的start()方法来启动一个线程。

　　　　　　　start()方法来启动一个线程，真正实现了多线程运行。这时无需等待run方法体代码执行完毕，可以直接继续执行下面的代码； 这时此线程是处于就绪状态， 并没有运行。

　　　　然后通过此Thread类调用方法run()来完成其运行状态， 这里方法run()称为线程体，它包含了要执行的这个线程的内容， Run方法运行结束， 此线程终止。然后CPU再调度其它线程。

　　　　　　 run()方法是在本线程里的，只是线程里的一个函数,而不是多线程的。 如果直接调用run(),其实就相当于是调用了一个普通函数而已，直接待用run()方法必须等待run()方法执行完毕

　　　　才能执行下面的代码，所以执行路径还是只有一条，根本就没有线程的特征，所以在多线程执行时要使用start()方法而不是run()方法。

　　　　6、线程的调度

1、新建状态(New)：新创建了一个线程对象。

　　　　　　2、就绪状态(Runnable)：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于“可运行线程池”中，

　　　　　　　　　　　　　　　　　　变得可运行，只等待获取CPU的使用权。即在就绪状态的进程除CPU之外，其它的运行所需资源都已全部获得。

　　　　　　3、运行状态(Running)：就绪状态的线程获取了CPU，执行程序代码。

　　　　　　4、阻塞状态(Blocked)：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。

　　　　　　　　阻塞的情况分三种：

　　　　　　　　　　(1)、等待阻塞：运行的线程执行wait()方法，该线程会释放占用的所有资源，JVM会把该线程放入“等待池”中。

　　　　　　　　　　　　　　　　　　进入这个状态后，是不能自动唤醒的，必须依靠其他线程调用notify()或notifyAll()方法才能被唤醒，

　　　　　　　　　　(2)、同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入“锁池”中。

　　　　　　　　　　(3)、其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。

　　　　　　　　　　　　　　　　　　当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

　　　　　　5、死亡状态(Dead)：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

　　　　　　思考：（1）sleep() 和 wait() 有什么区别？

　　　　　　　　sleep()：方法是线程类（Thread）的静态方法，让调用线程进入睡眠状态，让出执行机会给其他线程，等到休眠时间结束后，线程进入就绪状态和其他线程一起竞争cpu的执行时间。

　　　　　　因为sleep() 是static静态的方法，他不能改变对象的机锁，当一个synchronized块中调用了sleep() 方法，线程虽然进入休眠，但是对象的机锁没有被释放，其他线程依然无法访问这个

　　　　　　对象。

　　　　　　　　wait()：wait()是Object类的方法，当一个线程执行到wait方法时，它就进入到一个和该对象相关的等待池，同时释放对象的机锁，使得其他线程能够访问，

　　　　　　可以通过notify，notifyAll方法来唤醒等待的线程

　　　　　　　　（2）notify()和 notifyAll()有什么区别？

　　　　　　　　如果线程调用了对象的 wait()方法，那么线程便会处于该对象的等待池中，等待池中的线程不会去竞争该对象的锁。

　　　　　　　　 当有线程调用了对象的 notifyAll()方法（唤醒所有 wait 线程）或 notify()方法（只随机唤醒一个 wait 线程），被唤醒的的线程便会进入该对象的锁池中，锁池中的线程会

　　　　　　去竞争该对象锁。也就是说，调用了notify后只要一个线程会由等待池进入锁池，而notifyAll会将该对象等待池内的所有线程移动到锁池中，等待锁竞争。

　　　　　　　　 优先级高的线程竞争到对象锁的概率大，假若某线程没有竞争到该对象锁，它还会留在锁池中，唯有线程再次调用 wait()方法，它才会重新回到等待池中。而竞争到对象锁的线程

　　　　　　则继续往下执行，直到执行完了 synchronized 代码块，它会释放掉该对象锁，这时锁池中的线程会继续竞争该对象锁。

　　2)同步

　　　　（1）什么是死锁？

　　　　　　死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统

　　　　产生了死锁，这些永远在互相等待的进程称为死锁进程。是操作系统层面的一个错误，是进程死锁的简称，最早在 1965 年由 Dijkstra 在研究银行家算法时提出的，它是计算机操作系统

　　　　乃至整个并发程序设计领域最难处理的问题之一。

　　　(2)怎么防止死锁？

　　　　死锁的四个必要条件：

　　　　　　1、互斥条件：进程对所分配到的资源不允许其他进程进行访问，若其他进程访问该资源，只能等待，直至占有该资源的进程使用完成后释放该资源

　　　　　　2、请求和保持条件：进程获得一定的资源之后，又对其他资源发出请求，但是该资源可能被其他进程占有，此事请求阻塞，但又对自己获得的资源保持不放

　　　　　　3、不可剥夺条件：是指进程已获得的资源，在未完成使用之前，不可被剥夺，只能在使用完后自己释放

　　　　　　4、环路等待条件：是指进程发生死锁后，若干进程之间形成一种头尾相接的循环等待资源关系

　　　　这四个条件是死锁的必要条件，只要系统发生死锁，这些条件必然成立，而只要上述条件之 一不满足，就不会发生死锁。理解了死锁的原因，尤其是产生死锁的四个必要条件，

　　　　就可以最大可能地避免、预防和 解除死锁。所以，在系统设计、进程调度等方面注意如何不让这四个必要条件成立，如何确 定资源的合理分配算法，避免进程永久占据系统资源。

　　　　此外，也要防止进程在处于等待状态的情况下占用资源。因此，对资源的分配要给予合理的规划。

　　　　(3)说一下 synchronized 底层实现原理？

　　　　　　synchronized可以保证方法或者代码块在运行时，同一时刻只有一个方法可以进入到临界区，同时它还可以保证共享变量的内存可见性。Java中每一个对象都可以作为锁，

　　　　这是synchronized实现同步的基础：

　　　　　　　　普通同步方法，锁是当前实例对象

　　　　　　　　静态同步方法，锁是当前类的class对象

　　　　　　　　同步方法块，锁是括号里面的对象

　　　  (4)synchronized 和 Lock 有什么区别？

　　　　　　首先synchronized是java内置关键字，在jvm层面，Lock是个java类；

　　　　　　synchronized无法判断是否获取锁的状态，Lock可以判断是否获取到锁；

　　　　　　synchronized会自动释放锁(a 线程执行完同步代码会释放锁 ；b 线程执行过程中发生异常会释放锁)，Lock需在finally中手工释放锁（unlock()方法释放锁），否则容易造成线程死锁；

　　　　　　用synchronized关键字的两个线程1和线程2，如果当前线程1获得锁，线程2线程等待。如果线程1阻塞，线程2则会一直等待下去，而Lock锁就不一定会等待下去，如果尝试获取不到锁，

　　　　线程可以不用一直等待就结束了；

　　　　　　synchronized的锁可重入、不可中断、非公平，而Lock锁可重入、可判断、可公平（两者皆可）；

　　　　　　Lock锁适合大量同步的代码的同步问题，synchronized锁适合代码少量的同步问题。