Java 多线程入门大全

接触多线程已经不少时间了,也做了不少事情,但是一直觉得用起来不那么顺手,在debug的时候,往往会比较担心在同步上出什么问题,想起"程序员最怕的是自己写的代码"这句话,觉得真是不假.
 
 终于有一天,我觉得是时候把这个问题弄清楚了,所以,我就在网上找相关的内容看,结果竟然是找不到在我这个阶段应该看的,不是太简单,就是一笔带过,不知所云.
 
 废了九牛二虎之力,终于差不多弄清楚了,其中有不少误区,以前认为的和真理相差甚大.想起自己花费的时间,真是觉得有点多,所以把它写出来,一是防止自己以后又会忘掉,二是给像我一样的似懂非懂者留下一点可以参考的东东.
 闲话少说,转入正题!

 

 先从线程的创建说起.线程的创建一共有两种形式:

 

 一种是继承自Thread类.Thread
 类是一个具体的类，即不是抽象类，该类封装了线程的行为。要创建一个线程，程序员必须创建一个从 Thread 类导出的新类。程序员通过覆盖
 Thread 的 run() 函数来完成有用的工作。用户并不直接调用此函数；而是通过调用 Thread 的 start()
 函数，该函数再调用 run()。
 
 例如:
 public class Test extends Thread{
   public Test(){
   }
   public static void main(String args[]){
     Test t1 = new Test();
     Test t2 = new Test();
     t1.start();
     t2.start();
   }
   public void run(){
     file://do thread's things
   }
 }

 

 另一种是实现Runnable接口,此接口只有一个函数，run()，此函数必须由实现了此接口的类实现。
 
 例如:
 public class Test implements Runnable{
   Thread thread1;
   Thread thread2;
   public Test(){
     thread1 = new Thread(this,"1");
     thread2 = new Thread(this,"2");
   }
   public static void main(String args[]){
     Test t = new Test();
     t.startThreads();
   }
   public void run(){
     file://do thread's things
   }
   public void startThreads(){
     thread1.start();
     thread2.start();
   }
 }
 两种创建方式看起来差别不大,但是弄不清楚的话，也许会将你的程序弄得一团糟。两者区别有以下几点：
 1.当你想继承某一其它类时,你只能用后一种方式.
 2.第一种因为继承自Thread,只创建了自身对象,但是在数量上，需要几个线程，就得创建几个自身对象；第二种只创建一个自身对象，却创建几个Thread对象.而两种方法重大的区别就在于此，请你考虑：如果你在第一种里创建数个自身对象并且start()后，你会发现好像synchronized不起作用了，已经加锁的代码块或者方法居然同时可以有几个线程进去，而且同样一个变量，居然可以有好几个线程同时可以去更改它。（例如下面的代码）这是因为，在这个程序中，虽然你起了数个线程，可是你也创建了数个对象，而且，每个线程对应了每个对象也就是说，每个线程更改和占有的对象都不一样，所以就出现了同时有几个线程进入一个方法的现象，其实，那也不是一个方法，而是不同对象的相同的方法。所以，这时候你要加锁的话，只能将方法或者变量声明为静态，将static加上后，你就会发现，线程又能管住方法了，同时不可能有两个线程进入同样一个方法，那是因为，现在不是每个对象都拥有一个方法了，而是所有的对象共同拥有一个方法，这个方法就是静态方法。
 
 而你如果用第二种方法使用线程的话，就不会有上述的情况，因为此时，你只创建了一个自身对象，所以，自身对象的属性和方法对于线程来说是共有的。
 因此，我建议，最好用后一种方法来使用线程。
 public class mainThread extends Thread{
   int i=0;
   public static void main(String args[]){
 mainThread m1 = new mainThread();
 mainThread m2 = new mainThread();
 mainThread m3 = new mainThread();
 mainThread m4 = new mainThread();
 mainThread m5 = new mainThread();
 mainThread m6 = new mainThread();
 m1.start();
 m2.start();
 m3.start();
 m4.start();
 m5.start();
 m6.start();
   }
   public synchronized void t1(){
 i=++i;
 try{
   Thread.sleep(500);
 }
 catch(Exception e){}
 file://每个线程都进入各自的t1()方法，分别打印各自的i
 System.out.println(Thread.currentThread().getName()+" "+i);
   }
   public void run(){
 synchronized(this){
   while (true) {
     t1();
   }
 }
   }
 }

 

 下面我们来讲synchronized的4种用法吧:
 
 1.方法声明时使用,放在范围操作符(public等)之后,返回类型声明(void等)之前.即一次只能有一个线程进入该方法,其他线程要想在此时调用该方法,只能排队等候,当前线程(就是在synchronized方法内部的线程)执行完该方法后,别的线程才能进入.
 
   例如:
   public synchronized void synMethod() {
     file://方法体
   }
 2.对某一代码块使用,synchronized后跟括号,括号里是变量,这样,一次只有一个线程进入该代码块.例如:
   public int synMethod(int a1){
     synchronized(a1) {
   file://一次只能有一个线程进入
     }
   }
 3.synchronized后面括号里是一对象,此时,线程获得的是对象锁.例如:
   public class MyThread implements Runnable {
     public static void main(String args[]) {
   MyThread mt = new MyThread();
   Thread t1 = new Thread(mt, "t1");
   Thread t2 = new Thread(mt, "t2");
   Thread t3 = new Thread(mt, "t3");
   Thread t4 = new Thread(mt, "t4");
   Thread t5 = new Thread(mt, "t5");
   Thread t6 = new Thread(mt, "t6");
   t1.start();
   t2.start();
   t3.start();
   t4.start();
   t5.start();
   t6.start();
     }
     public void run() {
   synchronized (this) {
  System.out.println(Thread.currentThread().getName());
   }
     }
   }

 
 对于3,如果线程进入,则得到对象锁,那么别的线程在该类所有对象上的任何操作都不能进行.在对象级使用锁通常是一种比较粗糙的方法。为什么要将整个对象都上锁，而不允许其他线程短暂地使用对象中其他同步方法来访问共享资源？如果一个对象拥有多个资源，就不需要只为了让一个线程使用其中一部分资源，就将所有线程都锁在外面。由于每个对象都有锁，可以如下所示使用虚拟对象来上锁：
   class FineGrainLock {
  MyMemberClass x, y;
  Object xlock = new Object(), ylock = new Object();
  public void foo() {
  synchronized(xlock) {
 file://access x here
  }
  file://do something here - but don't use shared resources
  synchronized(ylock) {
 file://access y here
  }
  }
  public void bar() {
  synchronized(this) {
 file://access both x and y here
  }
  file://do something here - but don't use shared resources
  }
   }
 
 4.synchronized后面括号里是类.例如:
   class ArrayWithLockOrder{
     private static long num_locks = 0;
     private long lock_order;
     private int[] arr;
     public ArrayWithLockOrder(int[] a)
     {
   arr = a;
   synchronized(ArrayWithLockOrder.class)
   {//-----------------------------------------这里
  num_locks++;  // 锁数加 1。
  lock_order = num_locks;  // 为此对象实例设置唯一的 lock_order。
   }
     }
     public long lockOrder()
     {
   return lock_order;
     }
     public int[] array()
     {
   return arr;
     }
   }
   class SomeClass implements Runnable
   {
     public int sumArrays(ArrayWithLockOrder a1,
    ArrayWithLockOrder a2)
     {
   int value = 0;
   ArrayWithLockOrder first = a1;   // 保留数组引用的一个
   ArrayWithLockOrder last = a2;    // 本地副本。
   int size = a1.array().length;
   if (size == a2.array().length)
   {
  if (a1.lockOrder() > a2.lockOrder())  // 确定并设置对象的锁定
  {    // 顺序。
    first = a2;
    last = a1;
  }
  synchronized(first) {   // 按正确的顺序锁定对象。
    synchronized(last) {
  int[] arr1 = a1.array();
  int[] arr2 = a2.array();
  for (int i=0; i    value += arr1[i] + arr2[i];
    }
  }
   }
   return value;
     }
     public void run() {
   //...
     }
   }
 
 
 对于4,如果线程进入,则线程在该类中所有操作不能进行,包括静态变量和静态方法,实际上,对于含有静态方法和静态变量的代码块的同步,我们通常用4来加锁.
 以上4种之间的关系：
 
 锁是和对象相关联的，每个对象有一把锁，为了执行synchronized语句，线程必须能够获得synchronized语句中表达式指定的对象的锁，一个对象只有一把锁，被一个线程获得之后它就不再拥有这把锁，线程在执行完synchronized语句后，将获得锁交还给对象。
 
 在方法前面加上synchronized修饰符即可以将一个方法声明为同步化方法。同步化方法在执行之前获得一个锁。如果这是一个类方法，那么获得的锁是和声明方法的类相关的Class类对象的锁。如果这是一个实例方法，那么此锁是this对象的锁。

下面谈一谈一些常用的方法:
   wait(),wait(long),notify(),notifyAll()等方法是当前类的实例方法,
 
     wait()是使持有对象锁的线程释放锁;
     wait(long)是使持有对象锁的线程释放锁时间为long(毫秒)后,再次获得锁,wait()和wait(0)等价;
     notify()是唤醒一个正在等待该对象锁的线程,如果等待的线程不止一个,那么被唤醒的线程由jvm确定;
     notifyAll是唤醒所有正在等待该对象锁的线程.
    
 在这里我也重申一下,我们应该优先使用notifyAll()方法,因为唤醒所有线程比唤醒一个线程更容易让jvm找到最适合被唤醒的线程.
 
 对于上述方法,只有在当前线程中才能使用,否则报运行时错误java.lang.IllegalMonitorStateException:
 current thread not owner.

 

 下面,我谈一下synchronized和wait()、notify()等的关系:
 1.有synchronized的地方不一定有wait,notify
 2.有wait,notify的地方必有synchronized.这是因为wait和notify不是属于线程类，而是每一个对象都具有的方法，而且，这两个方法都和对象锁有关，有锁的地方，必有synchronized。
 另外，请注意一点：如果要把notify和wait方法放在一起用的话，必须先调用notify后调用wait，因为如果调用完wait，该线程就已经不是current
 thread了。如下例：
 /**
  * Title:    Jdeveloper's Java Projdect
  * Description:  n/a
  * Copyright:    Copyright (c) 2001
  * Company:  soho  http://www.ChinaJavaWorld.com
  * @author jdeveloper@21cn.com
  * @version 1.0
  */
 import java.lang.Runnable;
 import java.lang.Thread;
 public class DemoThread
 implements Runnable {
   public DemoThread() {
 TestThread testthread1 = new TestThread(this, "1");
 TestThread testthread2 = new TestThread(this, "2");
 testthread2.start();
 testthread1.start();
   }
   public static void main(String[] args) {
 DemoThread demoThread1 = new DemoThread();
   }
   public void run() {
 TestThread t = (TestThread) Thread.currentThread();
 try {
   if (!t.getName().equalsIgnoreCase("1")) {
     synchronized (this) {
   wait();
     }
   }
   while (true) {
     System.out.println("@time in thread" + t.getName() + "=" +
  t.increaseTime());
     if (t.getTime() % 10 == 0) {
   synchronized (this) {
 
 System.out.println("****************************************");
  notify();
  if (t.getTime() == 100)
    break;
  wait();
   }
     }
   }
 }
 catch (Exception e) {
   e.printStackTrace();
 }
   }
 }
 class TestThread
 extends Thread {
   private int time = 0;
   public TestThread(Runnable r, String name) {
 super(r, name);
   }
   public int getTime() {
 return time;
   }
   public int increaseTime() {
 return++time;
   }
 }
 下面我们用生产者/消费者这个例子来说明他们之间的关系:
   public class test {
     public static void main(String args[]) {
   Semaphore s = new Semaphore(1);
   Thread t1 = new Thread(s, "producer1");
   Thread t2 = new Thread(s, "producer2");
   Thread t3 = new Thread(s, "producer3");
   Thread t4 = new Thread(s, "consumer1");
   Thread t5 = new Thread(s, "consumer2");
   Thread t6 = new Thread(s, "consumer3");
   t1.start();
   t2.start();
   t3.start();
   t4.start();
   t5.start();
   t6.start();
     }
   }
   class Semaphore
   implements Runnable {
     private int count;
     public Semaphore(int n) {
   this.count = n;
     }
     public synchronized void acquire() {
   while (count == 0) {
  try {
    wait();
  }
  catch (InterruptedException e) {
    file://keep trying
  }
   }
   count--;
     }
     public synchronized void release() {
   while (count == 10) {
  try {
    wait();
  }
  catch (InterruptedException e) {
    file://keep trying
  }
   }
   count++;
   notifyAll(); file://alert a thread that's blocking on this
   semaphore
     }
     public void run() {
   while (true) {
  if
   (Thread.currentThread().getName().substring(0,8).equalsIgnoreCase("consumer"))
   {
    acquire();
  }
  else if
   (Thread.currentThread().getName().substring(0,8).equalsIgnoreCase("producer"))
   {
    release();
  }
  System.out.println(Thread.currentThread().getName() + "
   " + count);
   }
     }
   }
   
 生产者生产,消费者消费,一般没有冲突,但当库存为0时,消费者要消费是不行的,但当库存为上限(这里是10)时,生产者也不能生产.请好好研读上面的程序,你一定会比以前进步很多.
  
 上面的代码说明了synchronized和wait,notify没有绝对的关系,在synchronized声明的方法、代码块中,你完全可以不用wait,notify等方法,但是,如果当线程对某一资源存在某种争用的情况下,你必须适时得将线程放入等待或者唤醒.

 

 文章终于写完了,基本上将我学习所得全部写出来了,不过也留下些许遗憾,比如synchronized后是类时的深入的说明及讨论.而且,文章由于自己能力有限,有些地方肯定会有错误,希望看过有何建议和批评,请发帖在下面,我会修正该文.谢谢!

 作者：qlampskyface
 和作者联系：djb_skyface@tom.com

< p>

< p>