Java 多线程(一)

参考自：http://lavasoft.blog.51cto.com/62575/27069/

http://www.360doc.com/relevant/8/9/9/6/276998_more.shtml

 

关于锁和同步，有一下几个要点：

1. 每个对象只有一个锁；当提到同步时，应该清楚在什么上同步？也就是说，在哪个对象上同步？

2. 不必同步类中所有的方法，类可以同时拥有同步和非同步方法。

3. 如果两个线程要执行一个类中的synchronized方法，并且两个线程使用相同的实例 来调用方法，那么一次只能有一个线程能够执行方法，另一个需要等待，直到锁被释放。也就是说：如果一个线程在对象上获得一个锁，就没有任何其他线程可以进入（该对象的）类中的任何一个同步方法。

      一个实例一个线程

      一个实例多个线程

      多个实例多个线程

      多个线程使用相同的实例 来调用synchronized方法，一次只有一个线程能够执行该方法，其它线程需要等待

      多个线程使用不同的实例 来调用synchronized方法，这些线程可同时执行该同步方法

4. 如果线程拥有同步和非同步方法，则非同步方法可以被多个线程自由访问而不受锁的限制。

5. 线程睡眠时，它所持的任何锁都不会释放。线程wait时，释放锁。

6. 线程可以获得多个锁。比如，在一个对象的同步方法里面调用另外一个对象的同步方法，则获取了两个对象的同步锁。

7. 在使用同步代码块时候，应该指定在哪个对象上同步，也就是说要获取哪个对象的锁。

问题总结

1. 问：一个线程在一代码块上锁，需要指定锁住的对象，如果锁的是this，那么别的线程可以再访问该对象的其它同步方法吗？

答：不可以。

例子：

class Mythread implements Runnable {
 public void method1() {
  Object o = new Object();
  /**
   * 一个线程得到this的锁，直到该线程执行完该代码块，
   * 其它线程才能访问同步方法method2
   */
  synchronized (this) {
   for (int i = 1; i <= 5; i++) {
    for (long j = 0; j < 100000000; j++);
    System.out.println(i + ":Thread-1---");
   }
  }
 }
 public synchronized void method2() {
  for (int i = 1; i <= 5; i++) {
   for (long j = 0; j < 100000000; j++);
   System.out.println(i + ":Thread-2");
  }
 }
 public void run() {
  if (Thread.currentThread().getName().equals("Thread-1")) {
   method1();
  } else
   method2();
 }
}
public class MethodAndBlockTest {
 public static void main(String[] args) {
  Mythread mt = new Mythread();
  //Mythread mt2 = new Mythread();如果这行注释打开，new t2s时构造函数中的参数替换为mt2，则输出结果就随机交替输出
  Thread t1 = new Thread(mt, "Thread-1");
  Thread t2 = new Thread(mt, "Thread-2");
  t1.start();
  t2.start();
 }
}
运行结果：
1:Thread-1---
2:Thread-1---
3:Thread-1---
4:Thread-1---
5:Thread-1---
1:Thread-2
2:Thread-2
3:Thread-2
4:Thread-2
5:Thread-2

 

2. 问：虚拟锁何时应用？

答：如果一个类有两个同步方法 m1，m2，多个线程调用m1方法时，只有一个线程能运行。就是两个分别调用m1，m2的线程时，也只有一个能运行。

大多说情况下，多个线程调用m1时需要保护一种资源，调用M2时要保护的是另一种资源，如果m1,m2都设成同步方法。两个分别调用这两个方法的线程其实并不产生冲突，但它们都要获取这个实例的锁(同步方法是同步this)而产生了不必要竞争。

这时就要用到虚拟锁。

即将m1和m2方法中各自保护的对象作为参数传进来，然后将同步方法改为同步代码块分别以a1,a2为参数，这样到不同线程调用这两个方法时就不会产生竞争了。

例子：

class SleepTest{
  String vLock1 = "vLock1";
  String vLock2 = "vLock2";
  public void m1(){
    synchronized(vLock1){
      System.out.println("111");
      try {
        Thread.sleep(10000);
      }
      catch (Exception e) {}
      //操作f1
    }
  }
  
  public void m2(){
     synchronized(vLock2){
       System.out.println("123");
       //操作f2
     }    
  }
}
class T1 extends Thread{
  SleepTest st;
  public T1(SleepTest st){
    this.st = st;
  }
  public void run(){
    st.m1();
  }
}
class T2 extends Thread{
  SleepTest st;
  public T2(SleepTest st){
    this.st = st;
  }
  public void run(){
    st.m2();
  }
}
public class Test {
    public static void main(String[] args) throws Exception{
      SleepTest st = new SleepTest();
      new T1(st).start();
      new T2(st).start();
    }
}

 

3. 问：多个线程访问同一个对象的方法,方法中的变量共享否？

答：方法中的局部变量是不共享的
     类变量共享
     多个线程访问不同对象的方法，都不共享

例子：

public class ThreadClog {
 public static void main(String[] args) {
  Consumer c = new Consumer();
  Consumer c1 = new Consumer();
  Thread t1 = new Thread(c, "Thread-1");
  Thread t2 = new Thread(c1, "Thread-2");
  t1.start();
  t2.start();
 }
}
class Consumer implements Runnable {
public void run() {
  int count = 0;
  while (true) {
     //int count=0;
     for (int i = 0; i < 11000; i++) {
     for (long j = 0; j < 900000000; j++);
     count++;
     System.out.println(Thread.currentThread().getName() + ": "
       + count);
    }
  }
 }
}

 

4. 问：一个线程从wait状态被唤醒后，是从改同步方法(或代码块)的起始处执行还是接着wait后面的语句执行？

答：接着wait()后面的语句执行

例子：

public class WaitTest {
 public static int flag = 0;
 public static void main(String[] args) throws InterruptedException {
  ThreadB b = new ThreadB();
  Thread t=new Thread(b,"Thread-1");
  Thread t1=new Thread(b,"Thread-2");
  t.start();
  t1.start();
 }
}
class ThreadB implements Runnable {
 private boolean flag = true;
 public void run() {
 
  if (Thread.currentThread().getName().equals("Thread-1")) {
   try {
    method1();
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
  }else{
   method2();
  }
 }
 
 public synchronized void method1() throws InterruptedException {
  System.out.println("--start!");
  Thread.sleep(2000);
  if (flag) {
   wait();
  }
  System.out.println("-----sysn1 end!");
 }
 public synchronized void method2() {
  synchronized (this) {
   System.out.println("sysn2 等待....");
   notify();
   flag = false;
   System.out.println("-----sysn2 end!");
  }
 }
}
运行结果：
--start!
sysn2 等待....
-----sysn2 end!
-----sysn1 end!

 

5. 问：join方法有什么作用？

答：确保调用join方法的线程执行完毕再执行其它线程

     也可以使用参数规定该线程可以保持运行的时间，过期无效

例子：

class OtherThread extends Thread{
 public OtherThread(String name){
  super(name);
 }
 public void run(){
  for(int i=0;i<5;i++){
   for(long j=0;j<10000000;j++);
   System.out.println(this.getName()+": "+i);
  }
 }
}
public class SimpleThread extends Thread {
 public SimpleThread(String name){
  super(name);
 }
 public void run(){
  for(int i=0;i<5;i++){
   for(long j=0;j<10000000;j++);
   System.out.println(this.getName()+": "+i);
   try {
    Thread.sleep(1000);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
  }
 }
 public static void main(String[] args) throws InterruptedException {
 
  Thread t1=new SimpleThread("张三");
  Thread t2=new OtherThread("李四");
  t1.start();
  t1.join();
  t2.start();
  t2.join(); 
  System.out.println("main over!");
 }
}
输出结果：
张三: 0
张三: 1
张三: 2
张三: 3
张三: 4
李四: 0
李四: 1
李四: 2
李四: 3
李四: 4
main over!

 

6.问：守护线程和用户线程的区别？

答：用户线程：Java虚拟机在它所有非守护线程已经离开后自动离开。
     守护线程：守护线程则是用来服务用户线程的，如果没有其他用户线程在运行，那么就没有可服务对象，也就没有理由继续下去。
    setDaemon(boolean on)方法必须在线程启动之前调用
    Java垃圾回收线程就是一个典型的守护线程

例子：

public class DaemonTest extends Thread {
 public DaemonTest(String name){
  super(name);
 }
 public void run(){
  for(int i=1;i<=100;i++){
   try{
    Thread.sleep(100);
   }catch(InterruptedException ex){
    
   }
   System.out.println(i);
  }
 }
 public static void main(String[] args) throws IOException {
  DaemonTest test=new DaemonTest("Daemon");
  test.setDaemon(true);
  test.start();
  System.out.println("Daemon is Daemon:"+test.isDaemon());
  Thread.sleep(300);
 }
}
运行结果：
Daemon is Daemon:true
1
2
3

 

7.问：Java创建线程的方法，以及给不同的创建方式创建的线程起名

8.问：线程与线程对象，线程与运行环境

9.问：线程的中断和中断线程

10.问：线程池