SCJP期末考试
个人感觉题目难度较低，但是也反映了许多我没有掌握到、掌握好的东西。做完试卷后有时间我就慢慢把一些东西记到草纸上，一张不够再问监考老师要一张，两位老师发现我在做什么后都觉得很有意思。其中的美女老师是我们上个学期的微机原理老师，那时候上她的我有时候就会冒出来回答问题争取平时成绩的。
进入正题。
1． 方法内的内部类仅能访问封装方法中的静态方法吗？
方法内的内部类可以访问任何封装类中定义的内容？
封装方法中的静态方法？
一般情况下方法内部是不允许再嵌套方法的，所以封装方法中的**方法一说很有问题，可能是抄题笔误。 方法内的内部类能够访问封装类内定义的任何方法，包括私有的。即第二句是正确的。
２．Ｏbject 的 public int hashCode()
A. 没有提供实现
B. 返回对象所包含的特定整数码。
D. 返回ＪＶＭ中关于Object类内在的固定数字
As much as is reasonably practical, the hashCode method defined by class Object does return distinct integers for distinct objects. (This is typically implemented by converting the internal address of the object into an integer, but this implementation technique is not required by the JavaTM programming language.)
3. 如果一个方法只定义了局部变量，那么线程上下文切换出现问题？
？？？？？？？？？？the answer is in the explaination about thread in the following.
4. 尝试运行下面的代码：
class MayBe{
private String sayYes(boolean b){
assert b:sayNo(b);
return "Yes";
}
private String sayNo(boolean b){
assert b:sayYes(b);
return "No";
}
public static void main(String args[]){
MayBe maybe=new MayBe();
maybe.sayYes(false);
}
}
系统断言可用，编译通过。
执行时，屏幕输出：Exception in thread “main” java.lang.StackOverflowError
5. Thread 中常用方法有哪些？作用分别是什么？
线程的生命周期？
public final void join()
throws InterruptedException
Waits for this thread to die.
public void run()
If this thread was constructed using a separate Runnable run object, then that Runnable object's run method is called; otherwise, this method does nothing and returns.
Subclasses of Thread should override this method.
public final void stop()
Deprecated. This method is inherently unsafe. Stopping a thread with Thread.stop causes it to unlock all of the monitors that it has locked (as a natural consequence of the unchecked ThreadDeath exception propagating up the stack).
It is permitted to stop a thread that has not yet been started. If the thread is eventually started, it immediately terminates.
public static void sleep(long millis)
throws InterruptedException
Causes the currently executing thread to sleep (temporarily cease execution) for the specified number of milliseconds. The thread does not lose ownership of any monitors.
public void start()
Causes this thread to begin execution; the Java Virtual Machine calls the run method of this thread.
The result is that two threads are running concurrently: the current thread (which returns from the call to the start method) and the other thread (which executes its run method).
public final void suspend()
Deprecated. This method has been deprecated, as it is inherently deadlock-prone. If the target thread holds a lock on the monitor protecting a critical system resource when it is suspended, no thread can access this resource until the target thread is resumed. If the thread that would resume the target thread attempts to lock this monitor prior to calling resume, deadlock results. Such deadlocks typically manifest themselves as "frozen" processes.
If the thread is alive, it is suspended and makes no further progress unless and until it is resumed.
public static void yield()
Causes the currently executing thread object to temporarily pause and allow other threads to execute.
通过调用start()方法启动县城，执行run()方法。调用start()方法只是启动线程，并不意味着线程可以立刻得到指向，这取决于线程获取资源的情况和CUP的占有情况。
通过调用setDaemon(Boolean)方法可以将一个线程设置为后台线程，该方法应在县城启动前调用，否则会抛出IllegalThreadStateException异常来。
l 守护线程是一类特殊的线程，它和普通线程的区别在于它并不是应用程序的核心部分，当一个应用程序的所有非守护线程终止运行时，即使仍然有守护线程在运行，应用程序也将终止，反之，只要有一个非守护线程在运行，应用程序就不会终止。守护线程一般被用于在后台为其它线程提供服务。
l 可以通过调用方法 isDaemon() 来判断一个线程是否是守护线程，也可以调用方法 setDaemon() 来将一个线程设为守护线程。
l Java 提供了大量方法来支持阻塞，下面让我们逐一分析。
n 1. sleep() 方法：sleep() 允许 指定以毫秒为单位的一段时间作为参数，它使得线程在指定的时间内进入阻塞状态，不能得到CPU 时间，指定的时间一过，线程重新进入可执行状态。典型地，sleep() 被用在等待某个资源就绪的情形：测试发现条件不满足后，让线程阻塞一段时间后重新测试，直到条件满足为止。
n 2. suspend() 和 resume() 方法：两个方法配套使用，suspend()使得线程进入阻塞状态，并且不会自动恢复，必须其对应的resume() 被调用，才能使得线程重新进入可执行状态。典型地，suspend() 和 resume() 被用在等待另一个线程产生的结果的情形：测试发现结果还没有产生后，让线程阻塞，另一个线程产生了结果后，调用 resume() 使其恢复。
n 3. yield() 方法：yield() 使得线程放弃当前分得的 CPU 时间，但是不使线程阻塞，即线程仍处于可执行状态，随时可能再次分得 CPU 时间。调用 yield() 的效果等价于调度程序认为该线程已执行了足够的时间从而转到另一个线程。
n 4. wait() 和 notify() 方法：两个方法配套使用，wait() 使得线程进入阻塞状态，它有两种形式，一种允许 指定以毫秒为单位的一段时间作为参数，另一种没有参数，前者当对应的 notify() 被调用或者超出指定时间时线程重新进入可执行状态，后者则必须对应的 notify() 被调用。
l 初看起来它们与 suspend() 和 resume() 方法对没有什么分别，但是事实上它们是截然不同的。区别的核心在于，前面叙述的所有方法，阻塞时都不会释放占用的锁（如果占用了的话），而这一对方法则相反。
l 上述的核心区别导致了一系列的细节上的区别。
n 首先，前面叙述的所有方法都隶属于 Thread 类，但是这一对却直接隶属于 Object 类，也就是说，所有对象都拥有这一对方法。初看起来这十分不可思议，但是实际上却是很自然的，因为这一对方法阻塞时要释放占用的锁，而锁是任何对象都具有的，调用任意对象的 wait() 方法导致线程阻塞，并且该对象上的锁被释放。 而调用 任意对象的notify()方法则导致因调用该对象的 wait() 方法而阻塞的线程中随机选择的一个解除阻塞（但要等到获得锁后才真正可执行）。
n 其次，前面叙述的所有方法都可在任何位置调用，但是这一对方法却必须在 synchronized 方法或块中调用，理由也很简单，只有在synchronized 方法或块中当前线程才占有锁，才有锁可以释放。
l 同样的道理，调用这一对方法的对象上的锁必须为当前线程所拥有，这样才有锁可以释放。因此，这一对方法调用必须放置在这样的 synchronized 方法或块中，该方法或块的上锁对象就是调用这一对方法的对象。若不满足这一条件，则程序虽然仍能编译，但在运行时会出现IllegalMonitorStateException 异常。
l suspend() 方法和不指定超时期限的 wait() 方法的调用都可能产生死锁。遗憾的是，Java 并不在语言级别上支持死锁的避免，我们在编程中必须小心地避免死锁。
l wait() 和 notify() 方法的上述特性决定了它们经常和synchronized 方法或块一起使用，将它们和操作系统的进程间通信机制作一个比较就会发现它们的相似性：synchronized方法或块提供了类似于操作系统原语的功能，它们的执行不会受到多线程机制的干扰，而这一对方法则相当于 block 和wakeup 原语（这一对方法均声明为 synchronized）。
l 它们的结合使得我们可以实现操作系统上一系列精妙的进程间通信的算法（如信号量算法），并用于解决各种复杂的线程间通信问题。
l 关于 wait() 和 notify() 方法最后再说明两点：
第一：调用 notify() 方法导致解除阻塞的线程是从因调用该对象的 wait() 方法而阻塞的线程中随机选取的，我们无法预料哪一个线程将会被选择，所以编程时要特别小心，避免因这种不确定性而产生问题。
第二：除了 notify()，还有一个方法 notifyAll() 也可起到类似作用，唯一的区别在于，调用 notifyAll() 方法将把因调用该对象的 wait() 方法而阻塞的所有线程一次性全部解除阻塞。当然，只有获得锁的那一个线程才能进入可执行状态。
第一：调用 notify() 方法导致解除阻塞的线程是从因调用该对象的 wait() 方法而阻塞的线程中随机选取的，我们无法预料哪一个线程将会被选择，所以编程时要特别小心，避免因这种不确定性而产生问题。
第二：除了 notify()，还有一个方法 notifyAll() 也可起到类似作用，唯一的区别在于，调用 notifyAll() 方法将把因调用该对象的 wait() 方法而阻塞的所有线程一次性全部解除阻塞。当然，只有获得锁的那一个线程才能进入可执行状态。
l 线程的三个部分
n 虚拟CPU
线程或执行上下文，被认为是带有自己的程序代码和数据的虚拟CPU的封装。
n 代码
n 数据
n 调用start()方法使线程所代表的虚拟CPU处于可运行状态，这意味着它可以由JVM调度并执行。但并不意味着线程就会立即运行。
l 由于同一进程的多个线程共享同一片存储空间，在带来方便的同时，也带来了访问冲突这个严重的问题。Java语言提供了专门机制以解决这种冲突，有效避免了同一个数据对象被多个线程同时访问。
l 在Java 技术中，每个对象都有一个和它相关联的标志。这个标志可以被认为是“锁标志”。
l synchronized 关键字使能和这个标志的交互，即允许独占地存取对象。
l 当线程运行到synchronized 语句，它检查作为参数传递的对象，并在继续执行之前试图从对象获得锁标志。
l 当另一个线程试图执行synchronized(this)语句时，它试图从this 对象获取锁标志。由于得不到标志，所以线程不能继续运行。然后，线程加入到与那个对象锁相关联的等待线程池中。当标志返回给对象时，某个等待这个标志的线程将得到这把锁并继续运行。
l 如果一个线程对同一个对象两次发出synchronized 调用，则在跳出最外层的块时，标志会正确地释放，而最内层的将被忽略。
l 对敏感数据的所有访问都应该是 synchronized
l synchronized 保护的敏感数据应该是 private
只有当所有对敏感数据的存取位于同步块内，synchronized()才会发生作用。所有由synchronized 块保护的敏感数据应当标记为private。考虑来自对象的敏感部分的数据的可存取性。如果它们不被标记为private，则它们可以由位于类定义之外的代码存取。这样，你必须确信其他程序员不会省略必需的保护。
l synchronized 方法控制对类成员变量 synchronized 方法都必须获得调用该方法的类实例的锁方能执行，否则所属线程阻塞，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。的访问：每个类实例对应一把锁，每个
l 这种机制确保了同一时刻对于每一个类实例，其所有声明为 synchronized 的成员函数中至多只有一个处于可执行状态（因为至多只有一个能够获得该类实例对应的锁），从而有效避免了类成员变量的访问冲突（只要所有可能访问类成员变量的方法均被声明为 synchronized）。
l 在 Java 中，不光是类实例，每一个类也对应一把锁，这样我们也可将类的静态成员函数声明为 synchronized ，以控制其对类的静态成员变量的访问。
cannot display the picture of thead states.....reffer to notebook
ＪＡＶＡ语言中的线程在整个生命周期中共有５种状态。
Ａ。 新建状态 当一个线程实例被创建时，线程处于新建状态，此时线程已经被初始化并分配了资源。
Ｂ。 就绪状态 线程已经具备运行条件，进入线程队列，排队等待ＣＰＵ，一旦获得ＣＰＵ使用权，就可进入运行状态。
Ｃ。 运行状态 当就绪状态的线程被调度获得ＣＰＵ资源时，便进入运行状态。定义在线程体中的run()方法被调用，从方法体第一条语句开始顺序执行。
Ｄ。 阻塞状态 处于运行状态的线程因时间的发生，而导致让出ＣＵＰ使用权，并中止当前执行，进入阻塞状态。处于阻塞状态的县城，只有当引起阻塞的原因被消除后，先必须转入就绪状态，才可在获取ＣＰＵ使用权从原来中止处开始继续执行。
Ｅ。 死亡状态 线程死亡的原因有两个，一个是正在正常运行的线程指向完全部工作，即执行完了run()方法，并正常退出；另一个是线程被提前强制中止，例如调用destroy()方法种植线程。处于死亡状态的线程不能被重新启动，即不具有继续运行的能力。如果启动一个处于死亡状态的线程，则IllegalThreadStateException异常被抛出。
l 线程组是一个 Java 特有的概念，在 Java 中，线程组是类ThreadGroup 的对象，每个线程都隶属于唯一一个线程组，这个线程组在线程创建时指定并在线程的整个生命期内都不能更改
l 你可以通过调用包含 ThreadGroup 类型参数的 Thread 类构造函数来指定线程属的线程组，若没有指定，则线程缺省地隶属于名为 system 的系统线程组。
l 在 Java 中，除了预建的系统线程组外，所有线程组都必须显式创建。在 Java 中，除系统线程组外的每个线程组又隶属于另一个线程组，你可以在创建线程组时指定其所隶属的线程组，若没有指定，则缺省地隶属于系统线程组。这样，所有线程组组成了一棵以系统线程组为根的树。
l Java 允许我们对一个线程组中的所有线程同时进行操作，比如我们可以通过调用线程组的相应方法来设置其中所有线程的优先级，也可以启动或阻塞其中的所有线程
l Java 的线程组机制的另一个重要作用是线程安全。线程组机制允许我们通过分组来区分有不同安全特性的线程，对不同组的线程进行不同的处理，还可以通过线程组的分层结构来支持不对等安全措施的采用。
l Java 的 ThreadGroup 类提供了大量的方法来方便我们对线程组树中的每一个线程组以及线程组中的每一个线程进行操作。