Java多线程基础知识总结笔记

本篇笔记记录一些在Java多线程编程中常见的关键字，比较简单和基础的就不写太详细了。

一、Thread类（其实也是应用了Runnable接口）和Runnable接口（只有一个run方法，应用该类必须重写run方法）

一般我们定义一个线程类，可以继承Thread类或者应用Runnable接口，不管是继承哪个，都要重写run方法。

比如我们定义一个线程类：

public class Threadtest implements  Runnable
{ 
    @Override
    void run()
     {
             //写你需要这个进程进行的操作
      }
}

然后在主方法里面生成线程对象并调用start()方法运行：

public static void main(String args[]){
             new Thread(new Threadtest()).start();
   }

一般来说线程有以下几种状态：

新生（New）：这个状态下我们通过new关键字生成了新的线程Thread对象，为它分配了内存空间，但是这个线程并不是存活状态；

就绪（Runnable）：线程对象调用start()方法，线程进入runnable状态，等待分配CPU资源。这个时候线程是存活的；

运行（Running）：获取CPU资源后，线程开始进行，run()方法被执行，直到线程结束，或者因为资源耗尽等原因被中断或挂起；

阻塞（Blocked）：线程调用join()、sleep()和wait()等方法而暂处阻塞状态；

死亡（Dead）：线程结束，或者因为异常而被迫中断或异常退出，生命周期结束。

 

三、sleep方法和wait方法
3.1、sleep方法（只释放CPU，不释放锁），比如一个变量i，好几个线程都要用到，线程A调用sleep方法只释放了CPU，但是A没有释放i的锁，而那几个线程又刚好需要i达到一定条件才能继续运行，所以线程A就算释放了CPU也没用。

 3.2、wait方法（释放CPU和锁），比如有两个进程，进程A调用wait方法之后，进程释放CPU和锁，要等待线程B调用notify方法或notifyAll方法来通知A，你可以来抢夺资源了，但是A不一定就能抢得到。

 

四、synchronized同步标志

使用场合：比如这里有个资源j，好几个线程都要用到，我们把它叫做竞争资源（竞态条件），对这样的共享资源我们就要进行同步操作，以免一个线程对这个变量的操作被另一个线程覆盖了。通常有两种使用方法：

 

1、public/private/protected 函数返回类型 synchronized 函数名（形参）
{
    //函数内容
}
例如：
public void synchronized FuncName()
{
    //do something 
}

2、public/private/protected 函数返回类型  函数名（形参）
{
        synchronized（this）
      ｛ 
             //需要进行同步操作的函数内容
       ｝
        //其他操作
}

下面来个经典的面试题：给个变量j给你，叫你写个两个函数（线程）一个对它进行累加操作，一个对它进行递减操作。然后在主函数里产生四个线程，两个进行累加，两个进行递减。

public class ThreadTest1
{
private int j;
public static void main(String args[]){
   ThreadTest1 tt=newThreadTest1();
   Inc inc=tt.new Inc();
   Dec dec=tt.new Dec();
   for(inti=0;i<2;i++){
       Thread t=newThread(inc);
       t.start();
           t=new Thread(dec);
       t.start();
       }
   }
private synchronized void inc(){
   j++;
  System.out.println(Thread.currentThread().getName()+"-inc:"+j);
   }
private synchronized void dec(){
   j--;
  System.out.println(Thread.currentThread().getName()+"-dec:"+j);
   }
class Inc implements Runnable{
   public void run(){
       for(inti=0;i<100;i++){
       inc();
       }
   }
}
class Dec implements Runnable{
   public void run(){
       for(inti=0;i<100;i++){
       dec();
       }
   }
}
}

五、Lock方法和unLock方法
jdk5.0版本及之前只有synchronized，后来就有了Lock方法，synchronized能做的事情Lock方法都能做，而且锁的获取和释放更加明确，因为编程人员需要明确给出释放锁的时机，是更严谨的机制。
这个的用法也比较简单，我们先给出下面的类定义，方便解释：

import java.util.concurrent.locks.*;   
public class LockTest
{
    Lock lock = new ReentrantLock();// 锁 
    //定义一个公共资源
    private int val = 0;
    //再定义两个私有类，两个类都应用Runnable接口：
    private class IncClass implements Runnable()
    {
         //重写run
         void run()
         {
               lock.lock();     //锁定
               try{
                     //对竞争资源的操作
                     val++;
                     System.out.println("现在value的值是"+val);
               }catch(Exception e){
               }
               lock.unlock();      //释放锁
         }
    }
    private class DecClass implements Runnable()
    {
         //重写run
         void run()
         {
               lock.lock();
               try{
                     val--;
                     System.out.println("现在value的值是"+val);
               }catch(Exception e){
               }
               lock.unlock();
         }
    }
    //主方法
    public static void main(String[] args) throws Exception
    {
                LockTest lt = new LockTest();
                for(int i = 0 ; i< 10 ; i++)
                {
                     new Thread(lt.new IncClass()).start();
                     new Thread(lt.new DecClass()).start();
                }
    }
}

上面的代码没编译运行过，因为直接在文本文档里面敲的，不过也就是那个意思。你要对一个竞态资源进行写操作的时候，先获得锁，这样其他进程没办法对它进行访问，操作完成之后释放锁。
为了有个确定能运行的例子，去抄了别人写的可以运行的测试代码过来：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class LockTest {
    /**
     * @paramargs
     */
    private int j;
    private Lock lock =new ReentrantLock();
    public static void main(String[] args) {
       // TODO Auto-generated method stub
       LockTest tt = new LockTest();
       for(int i=0;i<2;i++)
       {
           new Thread(tt.new Adder()).start();
           new Thread(tt.new Subtractor()).start();
       }
    }

//两个内部类，作为数据成员的形式出现
    private class Subtractor implements Runnable

    {
       @Override
       public void run() {
           // TODO Auto-generated methodstub
           while(true)
           {
             /*synchronized (ThreadTest.this) {      
                  System.out.println("j--="+ j--);
                  //这里抛异常了，锁能释放吗？
              }*/
              lock.lock();
              try
              {
                 System.out.println("j--="+ j--);
              }finally
              {
                  lock.unlock();
              }
           }
       }     
  }

    private class Adder implements Runnable
    {
       @Override
       public void run() {
           // TODO Auto-generated methodstub
           while(true)
           {
            /*synchronized (ThreadTest.this) {
              System.out.println("j++="+ j++);
              }*/
              lock.lock();
               try
              {
                  System.out.println("j++="+ j++);
              }finally
              {
                  lock.unlock();
              }            
           }        
       }
    }
}

如果是多个线程读取，一个线程进行写的话，只需要给进行写操作的进程锁即可，读取操作那些线程一般是不需要锁的。

 

 六、join方法

 因为join方法使用方法比较神奇，我看了有篇博文讲得很好，不过看了几遍还是比较晕乎，主要是因为运用得不多，所以理解不深刻。其实学习还是要用任务驱动的方式最高效，这种纯学但是没有运用条件和环境的学习是没什么效果的。

给出join方法的帮助文档：

 

 

它的字面意思是：等当前调用join方法的进程在限定时间内死亡，如果限定时间为0，则一直等待。它的实现是通过一个条件为“this.alive”的“this.wait”循环操作进行的，即是：只要判断这个进程存活，则进行“this.wait”循环，等这个进程终结的时候通过this.notifyAll来通知其他进程争夺资源。
最后推荐一篇写得还不错的博文，虽然排版有点惨不忍睹，不过内容是不错的：

http://java.chinaitlab.com/base/828720.html