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

- 日理万妓 2022-09-19 12:29 239阅读 0赞

本篇笔记记录一些在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
    public final void join(long millis, int nanos)
                    throws InterruptedException等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。 
    
    参数：
    millis - 以毫秒为单位的等待时间。
    nanos - 要等待的 0-999999 附加纳秒。 
    抛出： 
    IllegalArgumentException - 如果 millis 值为负，则 nanos 的值不在 0-999999 范围内。 
    InterruptedException - 如果任何线程中断了当前线程。当抛出该异常时，当前线程的中断状态 被清除。

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

[http://java.chinaitlab.com/base/828720.html][http_java.chinaitlab.com_base_828720.html]

[  
][http_java.chinaitlab.com_base_828720.html]

原文转载至：[Java多线程基础知识总结笔记][Java]

[http_java.chinaitlab.com_base_828720.html]: http://http://java.chinaitlab.com/base/828720.html
[Java]: http://www.cnblogs.com/nerohwang/p/3493952.html