多选题Which two of statements are true？（）AIt is possible to synchronize static methods.BWhen a thread has yielded as a result of yield（）， it releases its locks.CWhen a thread is sleeping as a result of sleep（）， it releases its locks.DThe Object.wait（） method

第1题：

Which two of statements are true？（）

• A、It is possible to synchronize static methods.
• B、When a thread has yielded as a result of yield（）， it releases its locks.
• C、When a thread is sleeping as a result of sleep（）， it releases its locks.
• D、The Object.wait（） method can be invoked only from a synchronized context.
• E、The Thread.sleep（） method can be invoked only from a synchronized context.
• F、When the thread scheduler receives a notify（） request， and notifies a thread， that thread immediately releases its lock.

第2题：

Which statements concerning the methods notify（） and notifyAll（） are true？  

• A、Instances of class Thread have a method called notify（）.
• B、A call to the method notify（） will wake the thread that currently owns the monitor of the object.
• C、The method notify（） is synchronized.
• D、The method notifyAll（） is defined in class Thread.
• E、When there is more than one thread waiting to obtain the monitor of an object， there is no way to be     sure which thread will be notified by the notify（） method.

第3题：

public class TestOne {  public static void main （String[] args） throws Exception {  Thread.sleep（3000）；  System.out.println（”sleep”）；  }  }  What is the result？（） 

• A、 Compilation fails.
• B、 An exception is thrown at runtime.
• C、 The code executes normally and prints “sleep”.
• D、 The code executes normally， but nothing is printed.

第4题：

Which statement is true？（）   

• A、 If only one thread is blocked in the wait method of an object， and another thread executes the modify on that same object， then the first thread immediately resumes execution.
• B、 If a thread is blocked in the wait method of an object， and another thread executes the notify method on the same object， it is still possible that the first thread might never resume execution.
• C、 If a thread is blocked in the wait method of an object， and another thread executes the notify method on the same object， then the first thread definitely resumes execution as a direct and sole consequence of the notify call.
• D、 If two threads are blocked in the wait method of one object， and another thread executes the notify method on the same object， then the first thread that executed the wait call first definitely resumes execution as a direct and sole consequence of the notify call.

第5题：

Which two statements are true about setting the per-thread buffers higher than required?（）

• A、More memory per thread is beneficial in all scenarios
• B、It causes increased overhead due to initial memory allocation
• C、It can affect system stability during peak load times, due to swapping
• D、It requires increasing the thread_cache_size variable

第6题：

Which two options describe how MySQL Server allocates memory?（）

• A、Thread memory is pre-allocated up to thread_cache_size for performance
• B、Each connection may have its own per-thread memory allocations
• C、Global memory resources are allocated at server startup
• D、Each thread allocates memory from a global pool

第7题：

第8题：

第9题：

第10题：

第11题：

第12题：

第13题：

public class A extends Thread {  A（） {  setDaemon（true）；  }  public void run（） {  （new B（））.start（）；  try {  Thread.sleep（60000）；  } catch （InterruptedException x） {}  System.out.println（“A done”）；  }  class B extends Thread {  public void run（） {  try {  Thread.sleep（60000）；  } catch （InterruptedException x） {}  System.out.println（“B done”）；  }  }  public static void main（String[] args） {  （new A（））.start（）；  }  }   What is the result？（）  

• A、 A done
• B、 B done
• C、 A done B done
• D、 B done A done
• E、 There is no exception that the application will print anything.
• F、 The application outputs “A done” and “B done”， in no guaranteed order.

第14题：

Given that t1 is a reference to a live thread， which is true？（）

• A、The Thread.sleep（） method can take t1 as an argument.
• B、The Object.notify（） method can take t1 as an argument.
• C、The Thread.yield（） method can take t1 as an argument.
• D、The Thread.setPriority（） method can take t1 as an argument.
• E、The Object.notify（） method arbitrarily chooses which thread to notify.

第15题：

public class TestSeven extends Thread {  private static int x；  public synchronized void doThings（） {  int current = x；  current++；  x = current；  }  public void run（） {  doThings（）；  }  }  Which is true？（） 

• A、 Compilation fails.
• B、 An exception is thrown at runtime.
• C、 Synchronizing the run（） method would make the class thread-safe.
• D、 The data in variable “x” are protected from concurrent access problems.
• E、 Declaring the doThings（） method as static would make the class thread-safe.
• F、 Wrapping the statements within doThings（） in a synchronized（new Object（）） {} block would make the class thread-safe.

第16题：

Which two statements are true？（）

• A、It is possible for more than two threads to deadlock at once.
• B、The JVM implementation guarantees that multiple threads cannot enter into a deadlocked state.
• C、Deadlocked threads release once their sleep（） method’s sleep duration has expired.
• D、Deadlocking can occur only when the wait（）， notify（）， and notifyAll（） methods are used incorrectly.
• E、It is possible for a single-threaded application to deadlock if synchronized blocks are used incorrectly.
• F、If a piece of code is capable of deadlocking， you cannot eliminate the possibility ofdeadlocking by insertinginvocations of Thread.yield（）.

第17题：

Which two statements are true?（）

• A、It is possible for more than two threads to deadlock at once.
• B、The JVM implementation guarantees that multiple threads cannot enter into a deadlocked state.
• C、Deadlocked threads release once their sleep() method's sleep duration has expired.
• D、Deadlocking can occur only when the wait(), notify(), and notifyAll() methods are used incorrectly.
• E、It is possible for a single-threaded application to deadlock if synchronized blocks are used incorrectly.
• F、If a piece of code is capable of deadlocking, you cannot eliminate the possibility of deadlocking by inserting invocations of Thread.yield().

第18题：

第19题：

第20题：

第21题：

第22题：

第23题：

第24题：