本篇笔记记录一些在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给你,叫你写个两个函数(线程)一个对它进行累加操作,一个对它进行递减操作。然后在主函数里产生四个线程,两个进行累加,两个进行递减。
![](http://img.e-com-net.com/image/info8/b8d97b5613f94ed2ba791cad57d0b2ed.gif)
![](http://img.e-com-net.com/image/info8/2f88dd3f1cd145f59c0e47b51acdbd4b.gif)
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方法都能做,而且锁的获取和释放更加明确,因为编程人员需要明确给出释放锁的时机,是更严谨的机制。
这个的用法也比较简单,我们先给出下面的类定义,方便解释:
![](http://img.e-com-net.com/image/info8/b8d97b5613f94ed2ba791cad57d0b2ed.gif)
![](http://img.e-com-net.com/image/info8/2f88dd3f1cd145f59c0e47b51acdbd4b.gif)
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(); } } }
上面的代码没编译运行过,因为直接在文本文档里面敲的,不过也就是那个意思。你要对一个竞态资源进行写操作的时候,先获得锁,这样其他进程没办法对它进行访问,操作完成之后释放锁。
为了有个确定能运行的例子,去抄了别人写的可以运行的测试代码过来:
![](http://img.e-com-net.com/image/info8/b8d97b5613f94ed2ba791cad57d0b2ed.gif)
![](http://img.e-com-net.com/image/info8/2f88dd3f1cd145f59c0e47b51acdbd4b.gif)
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