Java多线程整理

A、Java中实现多线程的方式有两种：继承Thread类，实现Runnable接口。

class Thread1 extend Thread{

      public void run(){

       }

}

class Runnable1 implements Runnable{

    public void run(){

    }

}

其实Thread也是实现Runnable接口的：

class Thread implements Runnable {
    //…
public void run() {
        if (target != null) {
             target.run();
        }
        }
}

两个孰优孰劣总结一下吧：

实现Runnable接口比继承Thread类所具有的优势：

1）：适合多个相同的程序代码的线程去处理同一个资源

2）：可以避免java中的单继承的限制

3）：增加程序的健壮性，代码可以被多个线程共享，代码和数据独立。

 

B、线程强制执行

package com.tmt.test_code.thread;

class JoinThread implements Runnable {
    public void run() {
        for (int i = 0; i < 3; i++) {
            System.out.println(Thread.currentThread().getName());
        }
    }
 
    public static void main(String[] args) {
        JoinThread he = new JoinThread();
        Thread demo = new Thread(he,"线程");
        demo.start();
        for(int i=0;i<10;++i){
            if(i>5){
                try{
                    demo.join();  //强制执行demo
                }catch (Exception e) {
                    e.printStackTrace();
                }
            }
            System.out.println("main 线程执行-->"+i);
        }
    }
}

执行结果：

线程
main 线程执行-->0
main 线程执行-->1
main 线程执行-->2
main 线程执行-->3
main 线程执行-->4
main 线程执行-->5
线程
线程
main 线程执行-->6
main 线程执行-->7
main 线程执行-->8
main 线程执行-->9

说明在执行到大于5时，如果demo对应的线程还未执行完毕，则必须等它执行完毕后才能继续执行下面的程序。

 

C、sleep()和wait()的区别

package com.tmt.test_code.thread;

public class DeadLockThread implements Runnable{
 /**
 * 一个简单的死锁类及显示sleep()和wait()的区别
 * @author iStar
 * 当类的对象field_1=1时（T1），先锁定lock_1,睡眠1000毫秒，然后锁定lock_2；
 * 而T1在睡眠的时候另一个flag=2的对象（T2）线程启动，先锁定lock_2,睡眠1000毫秒，等待T1释放lock_1；
 * T1睡眠结束后需要锁定lock_2才能继续执行，而此时lock_2已被T2锁定；
 * T2睡眠结束后需要锁定lock_1才能继续执行，而此时lock_1已被T1锁定；
 * T1、T2相互等待，都需要对方锁定的资源才能继续执行，从而死锁。
 */
 int field_1 = 1;
 static Object lock_1 = new int[1];
 static Object lock_2 = new int[1];

 public void run(){
  if(field_1 == 1){
   synchronized (lock_1) {
    try {
//     lock_1.wait(1000);
     Thread.sleep(1000);
    } catch (InterruptedException e) {
     e.printStackTrace();
    }
    synchronized (lock_2) {
     System.out.println("method1");
    }
   }
  }
  if(field_1 == 2){
   synchronized (lock_2) {
    try {
//     lock_2.wait(1000);
     Thread.sleep(1000);
    } catch (InterruptedException e) {
     e.printStackTrace();
    }
    synchronized (lock_1) {
     System.out.println("method2");
    }
   }
  }
 }
 
 public static void main(String [] arg){
  DeadLockThread deadLockThread1 = new DeadLockThread();
  DeadLockThread deadLockThread2 = new DeadLockThread();
  deadLockThread1.field_1 = 1;
  deadLockThread2.field_1 = 2;
  Thread thread1 = new Thread(deadLockThread1);
  Thread thread2 = new Thread(deadLockThread2);
  thread1.start();
  thread2.start();
  
 }
}

当使用Thread.sleep(1000)时，打印不出任何东西。当注释掉Thread.sleep(1000)，使用wait()时可以打印出method1 method2
说明：

1、在调用sleep()方法的过程中，线程不会释放对象锁。

2、在调用wait()方法的过程中，线程会释放对象锁,进入等待此对象的等待锁定池。只有针对此对象调用notify()方法后本线程才进入对象锁定池准备获取对象锁进入运行状态。

下面的例子也可以看出来

package com.tmt.test_code.thread;

/**
 * java中的sleep()和wait()的区别
 *
 * @author Hongten
 * @date 2013-12-10
 */
public class SleepWaitDeffirent {
 static Object object = new Object();

 public static void main(String[] args) {
  new Thread(new Thread1()).start();
  try {
   Thread.sleep(5000);
  } catch (Exception e) {
   e.printStackTrace();
  }
  new Thread(new Thread2()).start();
 }

 private static class Thread1 implements Runnable {
  @Override
  public void run() {
   synchronized (object) {
    System.out.println("enter thread1...");
    System.out.println("thread1 is waiting...");
    try {
     // 调用wait()方法，线程会放弃对象锁，进入等待此对象的等待锁定池
     object.wait();
    } catch (Exception e) {
     e.printStackTrace();
    }
    System.out.println("thread1 is going on ....");
    System.out.println("thread1 is over!!!");
   }
  }
 }

 private static class Thread2 implements Runnable {
  @Override
  public void run() {
   synchronized (object) {
    
    System.out.println("enter thread2....");
    System.out.println("thread2 is sleep....");
    // 只有针对此对象调用notify()方法后本线程才进入对象锁定池准备获取对象锁进入运行状态。
    object.notifyAll();
    // ==================
    // 区别
    // 如果我们把代码：TestD.class.notify();给注释掉，即TestD.class调用了wait()方法，但是没有调用notify()
    // 方法，则线程永远处于挂起状态。
    try {
     // sleep()方法导致了程序暂停执行指定的时间，让出cpu该其他线程，
     // 但是他的监控状态依然保持者，当指定的时间到了又会自动恢复运行状态。
     // 在调用sleep()方法的过程中，线程不会释放对象锁。
     Thread.sleep(100);
    } catch (Exception e) {
     e.printStackTrace();
    }
    System.out.println("thread2 is going on....");
    System.out.println("thread2 is over!!!");
    
   }
  
  }
 }
}