线程
1、操作系统中线程和进程的概念
进程:进程是指一个内存中运行的应用程序,每个进程都有自己独立的一块内存空间,一个进程中可以启动多个线程。
线程:线程是指进程中的一个执行流程,一个进程中可以运行多个线程。线程总是属于某个进程,进程中的多个线程共享进程的内存。
2、Java中的线程
(1)java.lang.Thread类的一个实例;
(2)线程的执行
①使用java.lang.Thread类
②使用java.lang.Runnable接口
(3)分类
①用户线程
②守候线程
当所有用户线程执行完毕的时候,JVM自动关闭。但是守候线程却不独立于JVM,守候线程一般是由操作系统或者用户自己创建的。
3、线程的创建与启动
(1)定义线程
扩展java.lang.Thread类,要注意此类中的run()方法,如果该线程是使用独立的Runnable运行对象构造的,则调用该Runnable对象的run方法;否则,该方法不执行任何操作并返回。Thread的子类应该重写该方法。
(2)实现java.lang.Runnable接口
使用实现接口Runnable的对象创建一个线程时,启动该线程将导致在独立执行的线程中调用对象的run方法。方法run的常规协定是,它可能执行任何所需的操作。
(3)实例化线程
①如果是扩展java.lang.Thread类的线程,则直接new即可。
②如果是实现了java.lang.Runnable接口的类,则用Thread的构造方法:
- Thread(Runnable target)
- Thread(Runnable target, String name)
- Thread(ThreadGroup group, Runnable target)
- Thread(ThreadGroup group, Runnable target, String name)
- Thread(ThreadGroup group, Runnable target, String name, long stackSize)
(4)启动线程
在线程的Thread对象上调用start()方法,而不是run()或者别的方法。
在调用start()方法之前:
- 线程处于新状态中,新状态指有一个Thread对象,但还没有一个真正的线程。
在调用start()方法之后:
- 启动新的执行线程(具有新的调用栈);
- 该线程从新状态转移到可运行状态;
- 当该线程获得机会执行时,其目标run()方法将运行。
注意:对Java来说,run()方法没有任何特别之处。像main()方法一样,它只是新线程知道调用的方法名称(和签名)。因此,在Runnable上或者Thread上调用run方法是合法的。但并不启动新的线程。
例子:实现Runnable接口的多线程例子
/** * 实现Runnable接口的类 * */ publicclass DoSomethingimplements Runnable { private String name; public DoSomething(String name) { this.name = name; } publicvoid run() { for (int i = 0; i < 5; i++) { for (long k = 0; k < 100000000; k++) ; System.out.println(name + ": " + i); } } } /** * 测试Runnable类实现的多线程程序 * */ publicclass TestRunnable { publicstaticvoid main(String[] args) { DoSomething ds1 = new DoSomething("阿三"); DoSomething ds2 = new DoSomething("李四"); Thread t1 = new Thread(ds1); Thread t2 = new Thread(ds2); t1.start(); t2.start(); } }
执行结果:
李四: 0 阿三: 0 李四: 1 阿三: 1 李四: 2 李四: 3 阿三: 2 李四: 4 阿三: 3 阿三: 4 Process finished with exit code 0
(5)扩展Thread类实现的多线程例子
/** * 测试扩展Thread类实现的多线程程序 * */ publicclass TestThreadextends Thread{ public TestThread(String name) { super(name); } publicvoid run() { for(int i = 0;i<5;i++){ for(long k= 0; k <100000000;k++); System.out.println(this.getName()+" :"+i); } } publicstaticvoid main(String[] args) { Thread t1 = new TestThread("阿三"); Thread t2 = new TestThread("李四"); t1.start(); t2.start(); } }
执行结果:
阿三 :0 李四 :0 阿三 :1 李四 :1 阿三 :2 李四 :2 阿三 :3 阿三 :4 李四 :3 李四 :4 Process finished with exit code 0
(6)常见问题
- 获取当前线程的对象的方法是:Thread.currentThread();
- 当线程目标run()方法结束时该线程完成。
- 一旦线程启动,它就永远不能再重新启动。只有一个新的线程可以被启动,并且只能一次。一个可运行的线程或死线程可以被重新启动。
- 线程的调度是JVM的一部分,在一个CPU的机器上上,实际上一次只能运行一个线程。一次只有一个线程栈执行。JVM线程调度程序决定实际运行哪个处于可运行状态的线程。
4、线程的状态转换
(1)线程状态
线程的状态转换是线程控制的基础。线程状态总的可分为五大状态:分别是生、死、可运行、运行、等待/阻塞。
新状态:线程对象已经创建,还没有在其上调用start()方法。
可运行状态:当线程有资格运行,但调度程序还没有把它选定为运行线程时线程所处的状态。当start()方法调用时,线程首先进入可运行状态。在线程运行之后或者从阻塞、等待或睡眠状态回来后,也返回到可运行状态。
运行状态:线程调度程序从可运行池中选择一个线程作为当前线程时线程所处的状态。这也是线程进入运行状态的唯一一种方式。
等待/阻塞/睡眠状态:这是线程有资格运行时它所处的状态。实际上这个三状态组合为一种,其共同点是:线程仍旧是活的,但是当前没有条件运行。换句话说,它是可运行的,但是如果某件事件出现,他可能返回到可运行状态。
死亡态:当线程的run()方法完成时就认为它死去。这个线程对象也许是活的,但是,它已经不是一个单独执行的线程。线程一旦死亡,就不能复生。如果在一个死去的线程上调用start()方法,会抛出java.lang.IllegalThreadStateException异常。
(2)阻止线程执行
对于线程的阻止,考虑一下三个方面,不考虑IO阻塞的情况:睡眠、等待、因为需要一个对象的锁定而被阻塞。
①睡眠
Thread.sleep(long millis)和Thread.sleep(long millis, int nanos)静态方法强制当前正在执行的线程休眠(暂停执行),以“减慢线程”。当线程睡眠时,它入睡在某个地方,在苏醒之前不会返回到可运行状态。当睡眠时间到期,则返回到可运行状态。
线程睡眠的原因:线程执行太快,或者需要强制进入下一轮,因为Java规范不保证合理的轮换。
睡眠的位置:为了让其他线程有机会执行,可以将Thread.sleep()的调用放线程run()之内。这样才能保证该线程执行过程中会睡眠
睡眠的实现:调用静态方法。
try { Thread.sleep(123); } catch (InterruptedException e) { e.printStackTrace(); }
例子:
public void run() { for(int i = 0;i<5;i++){ // 很耗时的操作,用来减慢线程的执行 // for(long k= 0; k <100000000;k++); try { Thread.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); . } System.out.println(this.getName()+" :"+i); } }
运行结果:
阿三 :0 李四 :0 阿三 :1 阿三 :2 阿三 :3 李四 :1 李四 :2 阿三 :4 李四 :3 李四 :4 Process finished with exit code 0
这样,线程在每次执行过程中,总会睡眠3毫秒,睡眠了,其他的线程就有机会执行了。
注意:
- 线程睡眠是帮助所有线程获得运行机会的最好方法。
- 线程睡眠到期自动苏醒,并返回到可运行状态,不是运行状态。sleep()中指定的时间是线程不会运行的最短时间。因此,sleep()方法不能保证该线程睡眠到期后就开始执行。
- sleep()是静态方法,只能控制当前正在运行的线程。
例子:
/** * 一个计数器,计数到100,在每个数字之间暂停1秒,每隔10个数字输出一个字符串 * * @author leizhimin 2008-9-14 9:53:49 */ publicclass MyThreadextends Thread { publicvoid run() { for (int i = 0; i < 100; i++) { if ((i) % 10 == 0) { System.out.println("-------" + i); } System.out.print(i); try { Thread.sleep(1); System.out.print(" 线程睡眠1毫秒!\n"); } catch (InterruptedException e) { e.printStackTrace(); } } } publicstaticvoid main(String[] args) { new MyThread().start(); } }
运行结果:
-------0 0 线程睡眠1毫秒! 1 线程睡眠1毫秒! 2 线程睡眠1毫秒! 3 线程睡眠1毫秒! 4 线程睡眠1毫秒! 5 线程睡眠1毫秒! 6 线程睡眠1毫秒! 7 线程睡眠1毫秒! 8 线程睡眠1毫秒! 9 线程睡眠1毫秒! -------10 10 线程睡眠1毫秒! 11 线程睡眠1毫秒! 12 线程睡眠1毫秒! 13 线程睡眠1毫秒! ……………………………… ……………………………… ……………………………… 99 线程睡眠1毫秒! Process finished with exit code 0
(3)线程的优先级和线程让步yield()
线程的让步是通过Thread.yield()来实现的。
yield()方法的作用是:暂停当前正在执行的线程对象,并执行其他线程。
线程总是存在优先级,优先级范围在1~10之间。JVM线程调度程序是基于优先级的抢先调度机制。在大多数情况下,当前运行的线程优先级将大于或等于线程池中任何线程的优先级。但这仅仅是大多数情况。
当线程池中线程都具有相同的优先级,调度程序的JVM实现自由选择它喜欢的线程。这时候调度程序的操作有两种可能:一是选择一个线程运行,直到它阻塞或者运行完成为止。二是时间分片,为池内的每个线程提供均等的运行机会。
设置线程的优先级:线程默认的优先级是创建它的执行线程的优先级。可以通过setPriority(int newPriority)更改线程的优先级。例如:
Thread t = new MyThread(); t.setPriority(8); t.start();
线程优先级为1~10之间的正整数,JVM从不会改变一个线程的优先级。然而,1~10之间的值是没有保证的。一些JVM可能不能识别10个不同的值,而将这些优先级进行每两个或多个合并,变成少于10个的优先级,则两个或多个优先级的线程可能被映射为一个优先级。
线程默认优先级是5,Thread类中有三个常量,定义线程优先级范围:
static int MAX_PRIORITY
线程可以具有的最高优先级。
static int MIN_PRIORITY
线程可以具有的最低优先级。
static int NORM_PRIORITY
分配给线程的默认优先级。
(4)Thread.yield()方法
Thread.yield()方法作用是:暂停当前正在执行的线程对象,并执行其他线程。
yield()应该做的是让当前运行线程回到可运行状态,以允许具有相同优先级的其他线程获得运行机会。因此,使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是,实际中无法保证yield()达到让步目的,因为让步的线程还有可能被线程调度程序再次选中。
结论:yield()从未导致线程转到等待/睡眠/阻塞状态。在大多数情况下,yield()将导致线程从运行状态转到可运行状态,但有可能没有效果。
(5)join()方法
Thread的非静态方法join()让一个线程B“加入”到另外一个线程A的尾部。在A执行完毕之前,B不能工作。例如:
Thread t = new MyThread(); t.start(); t.join();
另外,join()方法还有带超时限制的重载版本。例如t.join(5000);则让线程等待5000毫秒,如果超过这个时间,则停止等待,变为可运行状态。
5、小结
线程离开运行状态的3种方法:
- 调用Thread.sleep():使当前线程睡眠至少多少毫秒(尽管它可能在指定的时间之前被中断)。
- 调用Thread.yield():不能保障太多事情,尽管通常它会让当前运行线程回到可运行性状态,使得有相同优先级的线程有机会执行。
- 调用join()方法:保证当前线程停止执行,直到该线程所加入的线程完成为止。然而,如果它加入的线程没有存活,则当前线程不需要停止。
除了以上三种方式外,还有下面几种特殊情况可能使线程离开运行状态:
- 线程的run()方法完成。
- 在对象上调用wait()方法(不是在线程上调用)。
- 线程不能在对象上获得锁定,它正试图运行该对象的方法代码。
- 线程调度程序可以决定将当前运行状态移动到可运行状态,以便让另一个线程获得运行机会,而不需要任何理由。
6、线程的同步与锁
(1)同步
线程的同步是为了防止多个线程访问一个数据对象时,对数据造成的破坏。
例如:两个线程ThreadA、ThreadB都操作同一个对象Foo对象,并修改Foo对象上的数据。
publicclass Foo { privateint x = 100; publicint getX() { return x; } publicint fix(int y) { x = x - y; return x; } } publicclass MyRunnableimplements Runnable { private Foo foo =new Foo(); publicstaticvoid main(String[] args) { MyRunnable r = new MyRunnable(); Thread ta = new Thread(r,"Thread-A"); Thread tb = new Thread(r,"Thread-B"); ta.start(); tb.start(); } publicvoid run() { for (int i = 0; i < 3; i++) { this.fix(30); try { Thread.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + " :当前foo对象的x值= " + foo.getX()); } } publicint fix(int y) { return foo.fix(y); } }
运行结果:
Thread-A : 当前foo对象的x值= 40 Thread-B : 当前foo对象的x值= 40 Thread-B : 当前foo对象的x值= -20 Thread-A : 当前foo对象的x值= -50 Thread-A : 当前foo对象的x值= -80 Thread-B : 当前foo对象的x值= -80 Process finished with exit code 0
从结果发现,这样的输出值明显是不合理的。原因是两个线程不加控制的访问Foo对象并修改其数据所致。如果要保持结果的合理性,只需要达到一个目的,就是将对Foo的访问加以限制,每次只能有一个线程在访问。这样就能保证Foo对象中数据的合理性了。
(2)锁
Java中每个对象都有一个内置锁,当程序运行到非静态的synchronized同步方法上时,自动获得与正在执行代码类的当前实例(this实例)有关的锁。获得一个对象的锁也称为获取锁、锁定对象、在对象上锁定或在对象上同步。当程序运行到synchronized同步方法或代码块时才该对象锁才起作用。
一个对象只有一个锁。所以,如果一个线程获得该锁,就没有其他线程可以获得锁,直到第一个线程释放(或返回)锁。这也意味着任何其他线程都不能进入该对象上的synchronized方法或代码块,直到该锁被释放。释放锁是指持锁线程退出了synchronized同步方法或代码块。
关于锁和同步,有以下几个要点:
只能同步方法,而不能同步变量和类;
每个对象只有一个锁;
- 不必同步类中所有的方法,类可以同时拥有同步和非同步方法。
- 如果两个线程要执行一个类中的synchronized方法,并且两个线程使用相同的实例来调用方法,那么一次只能有一个线程能够执行方法,另一个需要等待,直到锁被释放。也就是说:如果一个线程在对象上获得一个锁,就没有任何其他线程可以进入(该对象的)类中的任何一个同步方法。
- 如果线程拥有同步和非同步方法,则非同步方法可以被多个线程自由访问而不受锁的限制。
- 线程睡眠时,它所持的任何锁都不会释放。
- 线程可以获得多个锁。比如,在一个对象的同步方法里面调用另外一个对象的同步方法,则获取了两个对象的同步锁。
- 同步损害并发性,应该尽可能缩小同步范围。同步不但可以同步整个方法,还可以同步方法中一部分代码块。
- 在使用同步代码块时候,应该指定在哪个对象上同步,也就是说要获取哪个对象的锁。例如:
public int fix(int y) { synchronized (this) { x = x - y; } return x; }
(3)静态方法同步
要同步静态方法,需要一个用于整个类对象的锁,这个对象是就是这个类(XXX.class)。
例如:
public static synchronized int setName(String name){ Xxx.name = name; } 等价于 public static int setName(String name){ synchronized(Xxx.class){ Xxx.name = name; } }
7、线程安全类
当一个类已经很好的同步以保护它的数据时,这个类就称为“线程安全的”。
举个形象的例子,比如一个集合是线程安全的,有两个线程在操作同一个集合对象,当第一个线程查询集合非空后,删除集合中所有元素的时候。第二个线程也来执行与第一个线程相同的操作,也许在第一个线程查询后,第二个线程也查询出集合非空,但是当第一个执行清除后,第二个再执行删除显然是不对的,因为此时集合已经为空了。
8、线程死锁
当两个线程被阻塞,每个线程在等待另一个线程时就发生死锁。
publicclass DeadlockRisk { privatestaticclass Resource { publicint value; } private Resource resourceA =new Resource(); private Resource resourceB =new Resource(); publicint read() { synchronized (resourceA) { synchronized (resourceB) { return resourceB.value + resourceA.value; } } } publicvoid write(int a,int b) { synchronized (resourceB) { synchronized (resourceA) { resourceA.value = a; resourceB.value = b; } } } }
假设read()方法由一个线程启动,write()方法由另外一个线程启动。读线程将拥有resourceA锁,写线程将拥有resourceB锁,两者都坚持等待的话就出现死锁。
小结:
线程同步的目的是为了保护多个线程反问一个资源时对资源的破坏。
线程同步方法是通过锁来实现,每个对象都有切仅有一个锁,这个锁与一个特定的对象关联,线程一旦获取了对象锁,其他访问该对象的线程就无法再访问该对象的其他同步方法。
对于静态同步方法,锁是针对这个类的,锁对象是该类的Class对象。静态和非静态方法的锁互不干预。一个线程获得锁,当在一个同步方法中访问另外对象上的同步方法时,会获取这两个对象锁。
编写线程安全的类,需要时刻注意对多个线程竞争访问资源的逻辑和安全做出正确的判断,对“原子”操作做出分析,并保证原子操作期间别的线程无法访问竞争资源。
多个线程等待一个对象锁时,没有获取到锁的线程将发生阻塞。
9、线程的交互
(1)从java.lang.Object的类的三个方法来学习:
void notify()
唤醒在此对象监视器上等待的单个线程。
void notifyAll()
唤醒在此对象监视器上等待的所有线程。
void wait()
导致当前的线程等待,直到其他线程调用此对象的 notify()方法或 notifyAll()方法。
/** * 计算输出其他线程锁计算的数据 * */ publicclass ThreadA { publicstaticvoid main(String[] args) { ThreadB b = new ThreadB(); //启动计算线程 b.start(); //线程A拥有b对象上的锁。线程为了调用wait()或notify()方法,该线程必须是那个对象锁的拥有者 synchronized (b) { try { System.out.println("等待对象b完成计算。。。"); //当前线程A等待 b.wait(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("b对象计算的总和是:" + b.total); } } } /** * 计算1+2+3 ... +100的和 * */ publicclass ThreadBextends Thread { int total; publicvoid run() { synchronized (this) { for (int i = 0; i < 101; i++) { total += i; } //(完成计算了)唤醒在此对象监视器上等待的单个线程,在本例中线程A被唤醒 notify(); } } }
运行结果:
等待对象b完成计算。。。 b对象计算的总和是:5050 Process finished with exit code 0
多个线程在等待一个对象锁时候使用notifyAll()。
/** * 计算线程 * * @author leizhimin 2008-9-20 11:15:46 */ publicclass Calculatorextends Thread { int total; publicvoid run() { synchronized (this) { for (int i = 0; i < 101; i++) { total += i; } } //通知所有在此对象上等待的线程 notifyAll(); } } /** * 获取计算结果并输出 * * @author leizhimin 2008-9-20 11:15:22 */ publicclass ReaderResultextends Thread { Calculator c; public ReaderResult(Calculator c) { this.c = c; } publicvoid run() { synchronized (c) { try { System.out.println(Thread.currentThread() + "等待计算结果。。。"); c.wait(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread() + "计算结果为:" + c.total); } } publicstaticvoid main(String[] args) { Calculator calculator = new Calculator(); //启动三个线程,分别获取计算结果 new ReaderResult(calculator).start(); new ReaderResult(calculator).start(); new ReaderResult(calculator).start(); //启动计算线程 calculator.start(); } }
运行结果:
Thread[Thread-1,5,main]等待计算结果。。。 Thread[Thread-2,5,main]等待计算结果。。。 Thread[Thread-3,5,main]等待计算结果。。。 Exception in thread "Thread-0" java.lang.IllegalMonitorStateException: current thread not owner at java.lang.Object.notifyAll(Native Method) at threadtest.Calculator.run(Calculator.java:18) Thread[Thread-1,5,main]计算结果为:5050 Thread[Thread-2,5,main]计算结果为:5050 Thread[Thread-3,5,main]计算结果为:5050 Process finished with exit code 0
10、线程的调度
(1)休眠
Java线程调度是Java多线程的核心,只有良好的调度,才能充分发挥系统的性能,提高程序的执行效率。
线程休眠的目的是使线程让出CPU的最简单的做法之一,线程休眠时候,会将CPU资源交给其他线程,以便能轮换执行,当休眠一定时间后,线程会苏醒,进入准备状态等待执行。
线程休眠的方法是Thread.sleep(long millis)和Thread.sleep(long millis, int nanos),均为静态方法,哪个线程调用sleep,就休眠哪个线程。
/** * Java线程:线程的调度-休眠 * */ publicclass Test { publicstaticvoid main(String[] args) { Thread t1 = new MyThread1(); Thread t2 = new Thread(new MyRunnable()); t1.start(); t2.start(); } } class MyThread1 extends Thread { publicvoid run() { for (int i = 0; i < 3; i++) { System.out.println("线程1第" + i + "次执行!"); try { Thread.sleep(50); } catch (InterruptedException e) { e.printStackTrace(); } } } } class MyRunnableimplements Runnable { publicvoid run() { for (int i = 0; i < 3; i++) { System.out.println("线程2第" + i + "次执行!"); try { Thread.sleep(50); } catch (InterruptedException e) { e.printStackTrace(); } } } }
运行结果:
线程2第0次执行!
线程1第0次执行!
线程1第1次执行!
线程2第1次执行!
线程1第2次执行!
线程2第2次执行!
Process finished with exit code 0
(2)优先级
与线程休眠类似,线程的优先级仍然无法保障线程的执行次序。只不过,优先级高的线程获取CPU资源的概率较大,优先级低的并非没机会执行。
线程的优先级用1-10之间的整数表示,数值越大优先级越高,默认的优先级为5。
在一个线程中开启另外一个新线程,则新开线程称为该线程的子线程,子线程初始优先级与父线程相同。
/** * Java线程:线程的调度-优先级 * */ publicclass Test { publicstaticvoid main(String[] args) { Thread t1 = new MyThread1(); Thread t2 = new Thread(new MyRunnable()); t1.setPriority(10); t2.setPriority(1); t2.start(); t1.start(); } } class MyThread1 extends Thread { publicvoid run() { for (int i = 0; i < 10; i++) { System.out.println("线程1第" + i + "次执行!"); try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } } } } class MyRunnableimplements Runnable { publicvoid run() { for (int i = 0; i < 10; i++) { System.out.println("线程2第" + i + "次执行!"); try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } } } }
运行结果:
线程1第0次执行!
线程2第0次执行!
线程2第1次执行!
线程1第1次执行!
线程2第2次执行!
线程1第2次执行!
线程1第3次执行!
线程2第3次执行!
线程2第4次执行!
线程1第4次执行!
线程1第5次执行!
线程2第5次执行!
线程1第6次执行!
线程2第6次执行!
线程1第7次执行!
线程2第7次执行!
线程1第8次执行!
线程2第8次执行!
线程1第9次执行!
线程2第9次执行!
Process finished with exit code 0
(3)让步
线程的让步含义就是使当前运行着线程让出CPU资源,但是然给谁不知道,仅仅是让出,线程状态回到可运行状态。
线程的让步使用Thread.yield()方法,yield()为静态方法,功能是暂停当前正在执行的线程对象,并执行其他线程。
/** * Java线程:线程的调度-让步 * */ publicclass Test { publicstaticvoid main(String[] args) { Thread t1 = new MyThread1(); Thread t2 = new Thread(new MyRunnable()); t2.start(); t1.start(); } } class MyThread1 extends Thread { publicvoid run() { for (int i = 0; i < 10; i++) { System.out.println("线程1第" + i + "次执行!"); } } } class MyRunnableimplements Runnable { publicvoid run() { for (int i = 0; i < 10; i++) { System.out.println("线程2第" + i + "次执行!"); Thread.yield(); } } }
运行结果:
线程2第0次执行!
线程2第1次执行!
线程2第2次执行!
线程2第3次执行!
线程1第0次执行!
线程1第1次执行!
线程1第2次执行!
线程1第3次执行!
线程1第4次执行!
线程1第5次执行!
线程1第6次执行!
线程1第7次执行!
线程1第8次执行!
线程1第9次执行!
线程2第4次执行!
线程2第5次执行!
线程2第6次执行!
线程2第7次执行!
线程2第8次执行!
线程2第9次执行!
Process finished with exit code 0
(4)合并
线程的合并的含义就是将几个并行线程的线程合并为一个单线程执行,应用场景是当一个线程必须等待另一个线程执行完毕才能执行时可以使用join方法。
join为非静态方法,定义如下:
void join()
等待该线程终止。
void join(long millis)
等待该线程终止的时间最长为 millis毫秒。
void join(long millis,int nanos)
等待该线程终止的时间最长为 millis毫秒 + nanos 纳秒。
/** * Java线程:线程的调度-合并 * */ publicclass Test { publicstaticvoid main(String[] args) { Thread t1 = new MyThread1(); t1.start(); for (int i = 0; i < 20; i++) { System.out.println("主线程第" + i +"次执行!"); if (i > 2)try { //t1线程合并到主线程中,主线程停止执行过程,转而执行t1线程,直到t1执行完毕后继续。 t1.join(); } catch (InterruptedException e) { e.printStackTrace(); } } } } class MyThread1 extends Thread { publicvoid run() { for (int i = 0; i < 10; i++) { System.out.println("线程1第" + i + "次执行!"); } } }
运行结果:
主线程第0次执行!
主线程第1次执行!
主线程第2次执行!
线程1第0次执行!
主线程第3次执行!
线程1第1次执行!
线程1第2次执行!
线程1第3次执行!
线程1第4次执行!
线程1第5次执行!
线程1第6次执行!
线程1第7次执行!
线程1第8次执行!
线程1第9次执行!
主线程第4次执行!
主线程第5次执行!
主线程第6次执行!
主线程第7次执行!
主线程第8次执行!
主线程第9次执行!
主线程第10次执行!
主线程第11次执行!
主线程第12次执行!
主线程第13次执行!
主线程第14次执行!
主线程第15次执行!
主线程第16次执行!
主线程第17次执行!
主线程第18次执行!
主线程第19次执行!
Process finished with exit code 0
(5)守护线程
守护线程与普通线程写法上基本么啥区别,调用线程对象的方法setDaemon(true),则可以将其设置为守护线程。
守护线程使用的情况较少,但并非无用,举例来说,JVM的垃圾回收、内存管理等线程都是守护线程。还有就是在做数据库应用时候,使用的数据库连接池,连接池本身也包含着很多后台线程,监控连接个数、超时时间、状态等等。
setDaemon方法的详细说明:
publicfinalvoid setDaemon(boolean on)将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时,Java虚拟机退出。
该方法必须在启动线程前调用。
该方法首先调用该线程的 checkAccess方法,且不带任何参数。这可能抛出 SecurityException(在当前线程中)。
参数:
on - 如果为true,则将该线程标记为守护线程。
抛出:
IllegalThreadStateException - 如果该线程处于活动状态。
SecurityException - 如果当前线程无法修改该线程。
/** * Java线程:线程的调度-守护线程 * */ publicclass Test { publicstaticvoid main(String[] args) { Thread t1 = new MyCommon(); Thread t2 = new Thread(new MyDaemon()); t2.setDaemon(true); //设置为守护线程 t2.start(); t1.start(); } } class MyCommon extends Thread { publicvoid run() { for (int i = 0; i < 5; i++) { System.out.println("线程1第" + i + "次执行!"); try { Thread.sleep(7); } catch (InterruptedException e) { e.printStackTrace(); } } } } class MyDaemon implements Runnable { publicvoid run() { for (long i = 0; i < 9999999L; i++) { System.out.println("后台线程第" + i +"次执行!"); try { Thread.sleep(7); } catch (InterruptedException e) { e.printStackTrace(); } } } }
运行结果:
后台线程第0次执行!
线程1第0次执行!
线程1第1次执行!
后台线程第1次执行!
后台线程第2次执行!
线程1第2次执行!
线程1第3次执行!
后台线程第3次执行!
线程1第4次执行!
后台线程第4次执行!
后台线程第5次执行!
后台线程第6次执行!
后台线程第7次执行!
Process finished with exit code 0
(6)同步方法
线程的同步是保证多线程安全访问竞争资源的一种手段。
对于同步,在具体的Java代码中需要完成一下两个操作:
把竞争访问的资源标识为private;
同步哪些修改变量的代码,使用synchronized关键字同步方法或代码。
synchronized关键字使用说明
synchronized只能标记非抽象的方法,不能标识成员变量。
为了演示同步方法的使用,构建了一个信用卡账户,起初信用额为100w,然后模拟透支、存款等多个操作。显然银行账户User对象是个竞争资源,而多个并发操作的是账户方法oper(int x),当然应该在此方法上加上同步,并将账户的余额设为私有变量,禁止直接访问。
/** * Java线程:线程的同步 * */ publicclass Test { publicstaticvoid main(String[] args) { User u = new User("张三", 100); MyThread t1 = new MyThread("线程A", u, 20); MyThread t2 = new MyThread("线程B", u, -60); MyThread t3 = new MyThread("线程C", u, -80); MyThread t4 = new MyThread("线程D", u, -30); MyThread t5 = new MyThread("线程E", u, 32); MyThread t6 = new MyThread("线程F", u, 21); t1.start(); t2.start(); t3.start(); t4.start(); t5.start(); t6.start(); } } class MyThread extends Thread { private User u; privateint y = 0; MyThread(String name, User u, int y) { super(name); this.u = u; this.y = y; } publicvoid run() { u.oper(y); } } class User { private String code; privateint cash; User(String code, int cash) { this.code = code; this.cash = cash; } public String getCode() { return code; } publicvoid setCode(String code) { this.code = code; } /** * 业务方法 * @param x 添加x万元 */ publicsynchronizedvoid oper(int x) { try { Thread.sleep(10L); this.cash += x; System.out.println(Thread.currentThread().getName() + "运行结束,增加“" + x +"”,当前用户账户余额为:" + cash); Thread.sleep(10L); } catch (InterruptedException e) { e.printStackTrace(); } } @Override public String toString() { return"User{" + "code='" + code + '\'' + ", cash=" + cash + '}'; } }
输出结果:
线程A运行结束,增加“20”,当前用户账户余额为:120 线程F运行结束,增加“21”,当前用户账户余额为:141 线程E运行结束,增加“32”,当前用户账户余额为:173 线程C运行结束,增加“-80”,当前用户账户余额为:93 线程B运行结束,增加“-60”,当前用户账户余额为:33 线程D运行结束,增加“-30”,当前用户账户余额为:3 Process finished with exit code 0
void notify()
唤醒在此对象监视器上等待的单个线程。
void notifyAll()
唤醒在此对象监视器上等待的所有线程。
void wait()
导致当前的线程等待,直到其他线程调用此对象的 notify()方法或 notifyAll()方法。
void wait(long timeout)
导致当前的线程等待,直到其他线程调用此对象的 notify()方法或 notifyAll()方法,或者超过指定的时间量。
void wait(long timeout,int nanos)
导致当前的线程等待,直到其他线程调用此对象的 notify()方法或 notifyAll()方法,或者其他某个线程中断当前线程,或者已超过某个实际时间量。
(7)同步块
对于同步,除了同步方法外,还可以使用同步代码块,有时候同步代码块会带来比同步方法更好的效果。追其同步的根本的目的,是控制竞争资源的正确的访问,因此只要在访问竞争资源的时候保证同一时刻只能一个线程访问即可,因此Java引入了同步代码快的策略,以提高性能。在上个例子的基础上,对oper方法做了改动,由同步方法改为同步代码块模式,程序的执行逻辑并没有问题。
/** * Java线程:线程的同步-同步代码块 * */ publicclass Test { publicstaticvoid main(String[] args) { User u = new User("张三", 100); MyThread t1 = new MyThread("线程A", u, 20); MyThread t2 = new MyThread("线程B", u, -60); MyThread t3 = new MyThread("线程C", u, -80); MyThread t4 = new MyThread("线程D", u, -30); MyThread t5 = new MyThread("线程E", u, 32); MyThread t6 = new MyThread("线程F", u, 21); t1.start(); t2.start(); t3.start(); t4.start(); t5.start(); t6.start(); } } class MyThread extends Thread { private User u; privateint y = 0; MyThread(String name, User u, int y) { super(name); this.u = u; this.y = y; } publicvoid run() { u.oper(y); } } class User { private String code; privateint cash; User(String code, int cash) { this.code = code; this.cash = cash; } public String getCode() { return code; } publicvoid setCode(String code) { this.code = code; } /** * 业务方法 * * @param x 添加x万元 */ publicvoid oper(int x) { try { Thread.sleep(10L); synchronized (this) { this.cash += x; System.out.println(Thread.currentThread().getName() +"运行结束,增加“" + x +"”,当前用户账户余额为:" + cash); } Thread.sleep(10L); } catch (InterruptedException e) { e.printStackTrace(); } } @Override public String toString() { return"User{" + "code='" + code + '\'' + ", cash=" + cash + '}'; } }
运行结果:
线程E运行结束,增加“32”,当前用户账户余额为:132 线程B运行结束,增加“-60”,当前用户账户余额为:72 线程D运行结束,增加“-30”,当前用户账户余额为:42 线程F运行结束,增加“21”,当前用户账户余额为:63 线程C运行结束,增加“-80”,当前用户账户余额为:-17 线程A运行结束,增加“20”,当前用户账户余额为:3 Process finished with exit code 0
注意:
在使用synchronized关键字时候,应该尽可能避免在synchronized方法或synchronized块中使用sleep或者yield方法,因为synchronized程序块占有着对象锁,你休息那么其他的线程只能一边等着你醒来执行完了才能执行。不但严重影响效率,也不合逻辑。
同样,在同步程序块内调用yeild方法让出CPU资源也没有意义,因为你占用着锁,其他互斥线程还是无法访问同步程序块。当然与同步程序块无关的线程可以获得更多的执行时间。
(8)生产者消费者模型
对于多线程程序来说,不管任何编程语言,生产者和消费者模型都是最经典的。就像学习每一门编程语言一样,Hello World!都是最经典的例子。
实际上,准确说应该是“生产者-消费者-仓储”模型,离开了仓储,生产者消费者模型就显得没有说服力了。
对于此模型,应该明确一下几点:
1、生产者仅仅在仓储未满时候生产,仓满则停止生产。
2、消费者仅仅在仓储有产品时候才能消费,仓空则等待。
3、当消费者发现仓储没产品可消费时候会通知生产者生产。
4、生产者在生产出可消费产品时候,应该通知等待的消费者去消费。
此模型将要结合java.lang.Object的wait与notify、notifyAll方法来实现以上的需求。这是非常重要的。
/** * Java线程:并发协作-生产者消费者模型 * */ publicclass Test { publicstaticvoid main(String[] args) { Godown godown = new Godown(30); Consumer c1 = new Consumer(50, godown); Consumer c2 = new Consumer(20, godown); Consumer c3 = new Consumer(30, godown); Producer p1 = new Producer(10, godown); Producer p2 = new Producer(10, godown); Producer p3 = new Producer(10, godown); Producer p4 = new Producer(10, godown); Producer p5 = new Producer(10, godown); Producer p6 = new Producer(10, godown); Producer p7 = new Producer(80, godown); c1.start(); c2.start(); c3.start(); p1.start(); p2.start(); p3.start(); p4.start(); p5.start(); p6.start(); p7.start(); } } /** * 仓库 */ class Godown { publicstaticfinalint max_size = 100;//最大库存量 publicint curnum; //当前库存量 Godown() { } Godown(int curnum) { this.curnum = curnum; } /** * 生产指定数量的产品 * * @param neednum */ publicsynchronizedvoid produce(int neednum) { //测试是否需要生产 while (neednum + curnum > max_size) { System.out.println("要生产的产品数量" + neednum +"超过剩余库存量" + (max_size - curnum) +",暂时不能执行生产任务!"); try { //当前的生产线程等待 wait(); } catch (InterruptedException e) { e.printStackTrace(); } } //满足生产条件,则进行生产,这里简单的更改当前库存量 curnum += neednum; System.out.println("已经生产了" + neednum +"个产品,现仓储量为" + curnum); //唤醒在此对象监视器上等待的所有线程 notifyAll(); } /** * 消费指定数量的产品 * * @param neednum */ publicsynchronizedvoid consume(int neednum) { //测试是否可消费 while (curnum < neednum) { try { //当前的生产线程等待 wait(); } catch (InterruptedException e) { e.printStackTrace(); } } //满足消费条件,则进行消费,这里简单的更改当前库存量 curnum -= neednum; System.out.println("已经消费了" + neednum +"个产品,现仓储量为" + curnum); //唤醒在此对象监视器上等待的所有线程 notifyAll(); } } /** * 生产者 */ class Producer extends Thread { privateint neednum; //生产产品的数量 private Godown godown; //仓库 Producer(int neednum, Godown godown) { this.neednum = neednum; this.godown = godown; } publicvoid run() { //生产指定数量的产品 godown.produce(neednum); } } /** * 消费者 */ class Consumer extends Thread { privateint neednum; //生产产品的数量 private Godown godown; //仓库 Consumer(int neednum, Godown godown) { this.neednum = neednum; this.godown = godown; } publicvoid run() { //消费指定数量的产品 godown.consume(neednum); } }
运行结果:
已经生产了10个产品,现仓储量为40
已经生产了10个产品,现仓储量为50
已经消费了50个产品,现仓储量为0
已经生产了80个产品,现仓储量为80
已经消费了30个产品,现仓储量为50
已经生产了10个产品,现仓储量为60
已经消费了20个产品,现仓储量为40
已经生产了10个产品,现仓储量为50
已经生产了10个产品,现仓储量为60
已经生产了10个产品,现仓储量为70
Process finished with exit code 0
说明:
对于本例,要说明的是当发现不能满足生产或者消费条件的时候,调用对象的wait方法,wait方法的作用是释放当前线程的所获得的锁,并调用对象的notifyAll()方法,通知(唤醒)该对象上其他等待线程,使得其继续执行。这样,整个生产者、消费者线程得以正确的协作执行。
notifyAll() 方法,起到的是一个通知作用,不释放锁,也不获取锁。只是告诉该对象上等待的线程“可以竞争执行了,都醒来去执行吧”。
本例仅仅是生产者消费者模型中最简单的一种表示,本例中,如果消费者消费的仓储量达不到满足,而又没有生产者,则程序会一直处于等待状态,这当然是不对的。实际上可以将此例进行修改,修改为,根据消费驱动生产,同时生产兼顾仓库,如果仓不满就生产,并对每次最大消费量做个限制,这样就不存在此问题了,当然这样的例子更复杂,更难以说明这样一个简单模型。
(9)死锁
线程发生死锁可能性很小,即使看似可能发生死锁的代码,在运行时发生死锁的可能性也是小之又小。发生死锁的原因一般是两个对象的锁相互等待造成的。
/** * Java线程:并发协作-死锁 * */ publicclass Test { publicstaticvoid main(String[] args) { DeadlockRisk dead = new DeadlockRisk(); MyThread t1 = new MyThread(dead, 1, 2); MyThread t2 = new MyThread(dead, 3, 4); MyThread t3 = new MyThread(dead, 5, 6); MyThread t4 = new MyThread(dead, 7, 8); t1.start(); t2.start(); t3.start(); t4.start(); } } class MyThread extends Thread { private DeadlockRisk dead; privateint a, b; MyThread(DeadlockRisk dead, int a,int b) { this.dead = dead; this.a = a; this.b = b; } @Override publicvoid run() { dead.read(); dead.write(a, b); } } class DeadlockRisk { privatestaticclass Resource { publicint value; } private Resource resourceA =new Resource(); private Resource resourceB =new Resource(); publicint read() { synchronized (resourceA) { System.out.println("read():" + Thread.currentThread().getName() +"获取了resourceA的锁!"); synchronized (resourceB) { System.out.println("read():" + Thread.currentThread().getName() +"获取了resourceB的锁!"); return resourceB.value + resourceA.value; } } } publicvoid write(int a,int b) { synchronized (resourceB) { System.out.println("write():" + Thread.currentThread().getName() +"获取了resourceA的锁!"); synchronized (resourceA) { System.out.println("write():" + Thread.currentThread().getName() +"获取了resourceB的锁!"); resourceA.value = a; resourceB.value = b; } } } }
(11)新特征-线程池
线程池的基本思想还是一种对象池的思想,开辟一块内存空间,里面存放了众多(未死亡)的线程,池中线程执行调度由池管理器来处理。当有线程任务时,从池中取一个,执行完成后线程对象归池,这样可以避免反复创建线程对象所带来的性能开销,节省了系统的资源。
①固定大小的线程池
import java.util.concurrent.Executors; import java.util.concurrent.ExecutorService; /** * Java线程:线程池- * */ publicclass Test { publicstaticvoid main(String[] args) { //创建一个可重用固定线程数的线程池 ExecutorService pool = Executors.newFixedThreadPool(2); //创建实现了Runnable接口对象,Thread对象当然也实现了Runnable接口 Thread t1 = new MyThread(); Thread t2 = new MyThread(); Thread t3 = new MyThread(); Thread t4 = new MyThread(); Thread t5 = new MyThread(); //将线程放入池中进行执行 pool.execute(t1); pool.execute(t2); pool.execute(t3); pool.execute(t4); pool.execute(t5); //关闭线程池 pool.shutdown(); } } class MyThread extends Thread{ @Override publicvoid run() { System.out.println(Thread.currentThread().getName()+"正在执行。。。"); } }
运行结果:
pool-1-thread-1正在执行。。。 pool-1-thread-1正在执行。。。 pool-1-thread-1正在执行。。。 pool-1-thread-1正在执行。。。 pool-1-thread-2正在执行。。。 Process finished with exit code 0
②单任务线程池
在上例的基础上改一行创建pool对象的代码为:
//创建一个使用单个 worker线程的 Executor,以无界队列方式来运行该线程。 ExecutorService pool = Executors.newSingleThreadExecutor();
输出结果为:
pool-1-thread-1正在执行。。。 pool-1-thread-1正在执行。。。 pool-1-thread-1正在执行。。。 pool-1-thread-1正在执行。。。 pool-1-thread-1正在执行。。。 Process finished with exit code 0
对于以上两种连接池,大小都是固定的,当要加入的池的线程(或者任务)超过池最大尺寸时候,则入此线程池需要排队等待。
一旦池中有线程完毕,则排队等待的某个线程会入池执行。
③可变尺寸的线程池
与上面的类似,只是改动下pool的创建方式:
//创建一个可根据需要创建新线程的线程池,但是在以前构造的线程可用时将重用它们。 ExecutorService pool = Executors.newCachedThreadPool();
运行结果:
pool-1-thread-5正在执行。。。 pool-1-thread-1正在执行。。。 pool-1-thread-4正在执行。。。 pool-1-thread-3正在执行。。。 pool-1-thread-2正在执行。。。 Process finished with exit code 0
④延迟连接池
import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.TimeUnit; /** * Java线程:线程池- * */ publicclass Test { publicstaticvoid main(String[] args) { //创建一个线程池,它可安排在给定延迟后运行命令或者定期地执行。 ScheduledExecutorService pool = Executors.newScheduledThreadPool(2); //创建实现了Runnable接口对象,Thread对象当然也实现了Runnable接口 Thread t1 = new MyThread(); Thread t2 = new MyThread(); Thread t3 = new MyThread(); Thread t4 = new MyThread(); Thread t5 = new MyThread(); //将线程放入池中进行执行 pool.execute(t1); pool.execute(t2); pool.execute(t3); //使用延迟执行风格的方法 pool.schedule(t4, 10, TimeUnit.MILLISECONDS); pool.schedule(t5, 10, TimeUnit.MILLISECONDS); //关闭线程池 pool.shutdown(); } } class MyThread extends Thread { @Override publicvoid run() { System.out.println(Thread.currentThread().getName() + "正在执行。。。"); } }
运行结果:
pool-1-thread-1正在执行。。。 pool-1-thread-2正在执行。。。 pool-1-thread-1正在执行。。。 pool-1-thread-1正在执行。。。 pool-1-thread-2正在执行。。。 Process finished with exit code 0
⑤单任务延迟连接池
在四代码基础上,做改动
//创建一个单线程执行程序,它可安排在给定延迟后运行命令或者定期地执行。 ScheduledExecutorService pool = Executors.newSingleThreadScheduledExecutor();
运行结果:
pool-1-thread-1正在执行。。。 pool-1-thread-1正在执行。。。 pool-1-thread-1正在执行。。。 pool-1-thread-1正在执行。。。 pool-1-thread-1正在执行。。。 Process finished with exit code 0
⑥自定义线程池
import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.BlockingQueue; import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.TimeUnit; /** * Java线程:线程池-自定义线程池 * */ publicclass Test { publicstaticvoid main(String[] args) { //创建等待队列 BlockingQueue<Runnable> bqueue = new ArrayBlockingQueue<Runnable>(20); //创建一个单线程执行程序,它可安排在给定延迟后运行命令或者定期地执行。 ThreadPoolExecutor pool = new ThreadPoolExecutor(2,3,2,TimeUnit.MILLISECONDS,bqueue); //创建实现了Runnable接口对象,Thread对象当然也实现了Runnable接口 Thread t1 = new MyThread(); Thread t2 = new MyThread(); Thread t3 = new MyThread(); Thread t4 = new MyThread(); Thread t5 = new MyThread(); Thread t6 = new MyThread(); Thread t7 = new MyThread(); //将线程放入池中进行执行 pool.execute(t1); pool.execute(t2); pool.execute(t3); pool.execute(t4); pool.execute(t5); pool.execute(t6); pool.execute(t7); //关闭线程池 pool.shutdown(); } } class MyThread extends Thread { @Override publicvoid run() { System.out.println(Thread.currentThread().getName() + "正在执行。。。"); try { Thread.sleep(100L); } catch (InterruptedException e) { e.printStackTrace(); } } }
运行结果:
pool-1-thread-1正在执行。。。 pool-1-thread-2正在执行。。。 pool-1-thread-2正在执行。。。 pool-1-thread-1正在执行。。。 pool-1-thread-2正在执行。。。 pool-1-thread-1正在执行。。。 pool-1-thread-2正在执行。。。 Process finished with exit code 0
创建自定义线程池的构造方法很多,本例中参数的含义如下:
ThreadPoolExecutor
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue)
用给定的初始参数和默认的线程工厂及处理程序创建新的ThreadPoolExecutor。使用Executors工厂方法之一比使用此通用构造方法方便得多。
参数:
corePoolSize -池中所保存的线程数,包括空闲线程。
maximumPoolSize -池中允许的最大线程数。
keepAliveTime -当线程数大于核心时,此为终止前多余的空闲线程等待新任务的最长时间。
unit - keepAliveTime参数的时间单位。
workQueue -执行前用于保持任务的队列。此队列仅保持由execute方法提交的Runnable任务。
抛出:
IllegalArgumentException -如果 corePoolSize或 keepAliveTime小于零,或者 maximumPoolSize小于或等于零,或者 corePoolSize大于 maximumPoolSize。
NullPointerException -如果workQueue为 null
自定义连接池稍微麻烦些,不过通过创建的ThreadPoolExecutor线程池对象,可以获取到当前线程池的尺寸、正在执行任务的线程数、工作队列等等。
(12)新特征-有返回值的线程
可返回值的任务必须实现Callable接口,类似的,无返回值的任务必须Runnable接口。执行Callable任务后,可以获取一个Future的对象,在该对象上调用get就可以获取到Callable任务返回的Object了。
例子:
import java.util.concurrent.*; /** * Java线程:有返回值的线程 * */ publicclass Test { publicstaticvoid main(String[] args)throws ExecutionException, InterruptedException { //创建一个线程池 ExecutorService pool = Executors.newFixedThreadPool(2); //创建两个有返回值的任务 Callable c1 = new MyCallable("A"); Callable c2 = new MyCallable("B"); //执行任务并获取Future对象 Future f1 = pool.submit(c1); Future f2 = pool.submit(c2); //从Future对象上获取任务的返回值,并输出到控制台 System.out.println(">>>"+f1.get().toString()); System.out.println(">>>"+f2.get().toString()); //关闭线程池 pool.shutdown(); } } class MyCallableimplements Callable{ private String oid; MyCallable(String oid) { this.oid = oid; } @Override public Object call()throws Exception { return oid+"任务返回的内容"; } }
运行结果:
>>>A任务返回的内容 >>>B任务返回的内容 Process finished with exit code 0
(13)新特征-锁(上)
Condition:Condition将Object监视器方法(wait、notify和 notifyAll)分解成截然不同的对象,以便通过将这些对象与任意Lock实现组合使用,为每个对象提供多个等待 set(wait-set)。
Lock:Lock实现提供了比使用synchronized方法和语句可获得的更广泛的锁定操作。
ReadWriteLock:ReadWriteLock维护了一对相关的锁定,一个用于只读操作,另一个用于写入操作。
import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * Java线程:锁 * */ publicclass Test { publicstaticvoid main(String[] args) { //创建并发访问的账户 MyCount myCount = new MyCount("95599200901215522", 10000); //创建一个锁对象 Lock lock = new ReentrantLock(); //创建一个线程池 ExecutorService pool = Executors.newCachedThreadPool(); //创建一些并发访问用户,一个信用卡,存的存,取的取,好热闹啊 User u1 = new User("张三", myCount, -4000, lock); User u2 = new User("张三他爹", myCount, 6000, lock); User u3 = new User("张三他弟", myCount, -8000, lock); User u4 = new User("张三", myCount, 800, lock); //在线程池中执行各个用户的操作 pool.execute(u1); pool.execute(u2); pool.execute(u3); pool.execute(u4); //关闭线程池 pool.shutdown(); } } /** * 信用卡的用户 */ class User implements Runnable { private String name; //用户名 private MyCount myCount; //所要操作的账户 privateint iocash; //操作的金额,当然有正负之分了 private Lock myLock; //执行操作所需的锁对象 User(String name, MyCount myCount, int iocash, Lock myLock) { this.name = name; this.myCount = myCount; this.iocash = iocash; this.myLock = myLock; } publicvoid run() { //获取锁 myLock.lock(); //执行现金业务 System.out.println(name + "正在操作" + myCount +"账户,金额为" + iocash +",当前金额为" + myCount.getCash()); myCount.setCash(myCount.getCash() + iocash); System.out.println(name + "操作" + myCount +"账户成功,金额为" + iocash +",当前金额为" + myCount.getCash()); //释放锁,否则别的线程没有机会执行了 myLock.unlock(); } } /** * 信用卡账户,可随意透支 */ class MyCount { private String oid; //账号 privateint cash; //账户余额 MyCount(String oid, int cash) { this.oid = oid; this.cash = cash; } public String getOid() { return oid; } publicvoid setOid(String oid) { this.oid = oid; } publicint getCash() { return cash; } publicvoid setCash(int cash) { this.cash = cash; } @Override public String toString() { return"MyCount{" + "oid='" + oid + '\'' + ", cash=" + cash + '}'; } }
运行结果:
张三正在操作MyCount{oid='95599200901215522', cash=10000}账户,金额为-4000,当前金额为10000 张三操作MyCount{oid='95599200901215522', cash=6000}账户成功,金额为-4000,当前金额为6000 张三他爹正在操作MyCount{oid='95599200901215522', cash=6000}账户,金额为6000,当前金额为6000 张三他爹操作MyCount{oid='95599200901215522', cash=12000}账户成功,金额为6000,当前金额为12000 张三他弟正在操作MyCount{oid='95599200901215522', cash=12000}账户,金额为-8000,当前金额为12000 张三他弟操作MyCount{oid='95599200901215522', cash=4000}账户成功,金额为-8000,当前金额为4000 张三正在操作MyCount{oid='95599200901215522', cash=4000}账户,金额为800,当前金额为4000 张三操作MyCount{oid='95599200901215522', cash=4800}账户成功,金额为800,当前金额为4800 Process finished with exit code 0
(14)新特征-锁(下)
在上文中提到了Lock接口以及对象,使用它,很优雅的控制了竞争资源的安全访问,但是这种锁不区分读写,称这种锁为普通锁。为了提高性能,Java提供了读写锁,在读的地方使用读锁,在写的地方使用写锁,灵活控制,在一定程度上提高了程序的执行效率。Java中读写锁有个接口java.util.concurrent.locks.ReadWriteLock,也有具体的实现ReentrantReadWriteLock。
下面这个例子是在文例子的基础上,将普通锁改为读写锁,并添加账户余额查询的功能,代码如下:
import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.locks.ReadWriteLock; import java.util.concurrent.locks.ReentrantReadWriteLock; /** * Java线程:锁 * */ publicclass Test { publicstaticvoid main(String[] args) { //创建并发访问的账户 MyCount myCount = new MyCount("95599200901215522", 10000); //创建一个锁对象 ReadWriteLock lock = new ReentrantReadWriteLock(false); //创建一个线程池 ExecutorService pool = Executors.newFixedThreadPool(2); //创建一些并发访问用户,一个信用卡,存的存,取的取,好热闹啊 User u1 = new User("张三", myCount, -4000, lock, false); User u2 = new User("张三他爹", myCount, 6000, lock, false); User u3 = new User("张三他弟", myCount, -8000, lock, false); User u4 = new User("张三", myCount, 800, lock,false); User u5 = new User("张三他爹", myCount, 0, lock,true); //在线程池中执行各个用户的操作 pool.execute(u1); pool.execute(u2); pool.execute(u3); pool.execute(u4); pool.execute(u5); //关闭线程池 pool.shutdown(); } } /** * 信用卡的用户 */ class User implements Runnable { private String name; //用户名 private MyCount myCount; //所要操作的账户 privateint iocash; //操作的金额,当然有正负之分了 private ReadWriteLock myLock; //执行操作所需的锁对象 privateboolean ischeck; //是否查询 User(String name, MyCount myCount, int iocash, ReadWriteLock myLock,boolean ischeck) { this.name = name; this.myCount = myCount; this.iocash = iocash; this.myLock = myLock; this.ischeck = ischeck; } publicvoid run() { if (ischeck) { //获取读锁 myLock.readLock().lock(); System.out.println("读:" + name +"正在查询" + myCount +"账户,当前金额为" + myCount.getCash()); //释放读锁 myLock.readLock().unlock(); } else { //获取写锁 myLock.writeLock().lock(); //执行现金业务 System.out.println("写:" + name +"正在操作" + myCount +"账户,金额为" + iocash +",当前金额为" + myCount.getCash()); myCount.setCash(myCount.getCash() + iocash); System.out.println("写:" + name +"操作" + myCount +"账户成功,金额为" + iocash +",当前金额为" + myCount.getCash()); //释放写锁 myLock.writeLock().unlock(); } } } /** * 信用卡账户,可随意透支 */ class MyCount { private String oid; //账号 privateint cash; //账户余额 MyCount(String oid, int cash) { this.oid = oid; this.cash = cash; } public String getOid() { return oid; } publicvoid setOid(String oid) { this.oid = oid; } publicint getCash() { return cash; } publicvoid setCash(int cash) { this.cash = cash; } @Override public String toString() { return"MyCount{" + "oid='" + oid + '\'' + ", cash=" + cash + '}'; } }
运行结果:
写:张三正在操作MyCount{oid='95599200901215522', cash=10000}账户,金额为-4000,当前金额为10000 写:张三操作MyCount{oid='95599200901215522', cash=6000}账户成功,金额为-4000,当前金额为6000 写:张三他弟正在操作MyCount{oid='95599200901215522', cash=6000}账户,金额为-8000,当前金额为6000 写:张三他弟操作MyCount{oid='95599200901215522', cash=-2000}账户成功,金额为-8000,当前金额为-2000 写:张三正在操作MyCount{oid='95599200901215522', cash=-2000}账户,金额为800,当前金额为-2000 写:张三操作MyCount{oid='95599200901215522', cash=-1200}账户成功,金额为800,当前金额为-1200 读:张三他爹正在查询MyCount{oid='95599200901215522', cash=-1200}账户,当前金额为-1200 写:张三他爹正在操作MyCount{oid='95599200901215522', cash=-1200}账户,金额为6000,当前金额为-1200 写:张三他爹操作MyCount{oid='95599200901215522', cash=4800}账户成功,金额为6000,当前金额为4800 Process finished with exit code 0
(15)新特征-信号量
Java的信号量实际上是一个功能完毕的计数器,对控制一定资源的消费与回收有着很重要的意义,信号量常常用于多线程的代码中,并能监控有多少数目的线程等待获取资源,并且通过信号量可以得知可用资源的数目等等,这里总是在强调“数目”二字,但不能指出来有哪些在等待,哪些资源可用。
import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Semaphore; /** * Java线程:新特征-信号量 * */ publicclass Test { publicstaticvoid main(String[] args) { MyPool myPool = new MyPool(20); //创建线程池 ExecutorService threadPool = Executors.newFixedThreadPool(2); MyThread t1 = new MyThread("任务A", myPool, 3); MyThread t2 = new MyThread("任务B", myPool, 12); MyThread t3 = new MyThread("任务C", myPool, 7); //在线程池中执行任务 threadPool.execute(t1); threadPool.execute(t2); threadPool.execute(t3); //关闭池 threadPool.shutdown(); } } /** * 一个池 */ class MyPool { private Semaphore sp; //池相关的信号量 /** * 池的大小,这个大小会传递给信号量 * * @param size 池的大小 */ MyPool(int size) { this.sp =new Semaphore(size); } public Semaphore getSp() { return sp; } publicvoid setSp(Semaphore sp) { this.sp = sp; } } class MyThread extends Thread { private String threadname; //线程的名称 private MyPool pool; //自定义池 privateint x; //申请信号量的大小 MyThread(String threadname, MyPool pool, int x) { this.threadname = threadname; this.pool = pool; this.x = x; } publicvoid run() { try { //从此信号量获取给定数目的许可 pool.getSp().acquire(x); //todo:也许这里可以做更复杂的业务 System.out.println(threadname + "成功获取了" + x +"个许可!"); } catch (InterruptedException e) { e.printStackTrace(); } finally { //释放给定数目的许可,将其返回到信号量。 pool.getSp().release(x); System.out.println(threadname + "释放了" + x +"个许可!"); } } }
运行结果:
任务B成功获取了12个许可!
任务B释放了12个许可!
任务A成功获取了3个许可!
任务C成功获取了7个许可!
任务C释放了7个许可!
任务A释放了3个许可!
Process finished with exit code 0
从结果可以看出,信号量仅仅是对池资源进行监控,但不保证线程的安全,因此,在使用时候,应该自己控制线程的安全访问池资源。
(16)新特征-阻塞队列
阻塞队列是Java5线程新特征中的内容,Java定义了阻塞队列的接口java.util.concurrent.BlockingQueue,阻塞队列的概念是,一个指定长度的队列,如果队列满了,添加新元素的操作会被阻塞等待,直到有空位为止。同样,当队列为空时候,请求队列元素的操作同样会阻塞等待,直到有可用元素为止。
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ArrayBlockingQueue;
/** * Java线程:新特征-阻塞队列 * */ publicclass Test { publicstaticvoid main(String[] args)throws InterruptedException { BlockingQueue bqueue = new ArrayBlockingQueue(20); for (int i = 0; i < 30; i++) { //将指定元素添加到此队列中,如果没有可用空间,将一直等待(如果有必要)。 bqueue.put(i); System.out.println("向阻塞队列中添加了元素:" + i); } System.out.println("程序到此运行结束,即将退出----"); } }
输出结果:
向阻塞队列中添加了元素:0 向阻塞队列中添加了元素:1 向阻塞队列中添加了元素:2 向阻塞队列中添加了元素:3 向阻塞队列中添加了元素:4 向阻塞队列中添加了元素:5 向阻塞队列中添加了元素:6 向阻塞队列中添加了元素:7 向阻塞队列中添加了元素:8 向阻塞队列中添加了元素:9 向阻塞队列中添加了元素:10 向阻塞队列中添加了元素:11 向阻塞队列中添加了元素:12 向阻塞队列中添加了元素:13 向阻塞队列中添加了元素:14 向阻塞队列中添加了元素:15 向阻塞队列中添加了元素:16 向阻塞队列中添加了元素:17 向阻塞队列中添加了元素:18 向阻塞队列中添加了元素:19
可以看出,输出到元素19时候,就一直处于等待状态,因为队列满了,程序阻塞了。另外,阻塞队列还有更多实现类,用来满足各种复杂的需求:ArrayBlockingQueue, DelayQueue, LinkedBlockingQueue, PriorityBlockingQueue, SynchronousQueue,具体的API差别也很小。
(17)新特征-阻塞栈
对于阻塞栈,与阻塞队列相似。不同点在于栈是“后入先出”的结构,每次操作的是栈顶,而队列是“先进先出”的结构,每次操作的是队列头。
import java.util.concurrent.BlockingDeque; import java.util.concurrent.LinkedBlockingDeque; /** * Java线程:新特征-阻塞栈 * */ publicclass Test { publicstaticvoid main(String[] args)throws InterruptedException { BlockingDeque bDeque = new LinkedBlockingDeque(20); for (int i = 0; i < 30; i++) { //将指定元素添加到此阻塞栈中,如果没有可用空间,将一直等待(如果有必要)。 bDeque.putFirst(i); System.out.println("向阻塞栈中添加了元素:" + i); } System.out.println("程序到此运行结束,即将退出----"); } }
输出结果:
向阻塞栈中添加了元素:0 向阻塞栈中添加了元素:1 向阻塞栈中添加了元素:2 向阻塞栈中添加了元素:3 向阻塞栈中添加了元素:4 向阻塞栈中添加了元素:5 向阻塞栈中添加了元素:6 向阻塞栈中添加了元素:7 向阻塞栈中添加了元素:8 向阻塞栈中添加了元素:9 向阻塞栈中添加了元素:10 向阻塞栈中添加了元素:11 向阻塞栈中添加了元素:12 向阻塞栈中添加了元素:13 向阻塞栈中添加了元素:14 向阻塞栈中添加了元素:15 向阻塞栈中添加了元素:16 向阻塞栈中添加了元素:17 向阻塞栈中添加了元素:18 向阻塞栈中添加了元素:19
从上面结果可以看到,程序并没结束,二是阻塞住了,原因是栈已经满了,后面追加元素的操作都被阻塞了。
(18)新特征-条件变量
条件变量是Java5线程中很重要的一个概念,顾名思义,条件变量就是表示条件的一种变量。但是必须说明,这里的条件是没有实际含义的,仅仅是个标记而已,并且条件的含义往往通过代码来赋予其含义。条件变量都实现了java.util.concurrent.locks.Condition接口,条件变量的实例化是通过一个Lock对象上调用newCondition()方法来获取的,这样,条件就和一个锁对象绑定起来了。因此,Java中的条件变量只能和锁配合使用,来控制并发程序访问竞争资源的安全。条件变量的出现是为了更精细控制线程等待与唤醒,在Java5之前,线程的等待与唤醒依靠的是Object对象的wait()和notify()/notifyAll()方法,这样的处理不够精细。
下面以一个银行存取款的模拟程序为例来揭盖Java多线程条件变量的神秘面纱:
有一个账户,多个用户(线程)在同时操作这个账户,有的存款有的取款,存款随便存,取款有限制,不能透支,任何试图透支的操作都将等待里面有足够存款才执行操作。
import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * Java线程:条件变量 * */ publicclass Test { publicstaticvoid main(String[] args) { //创建并发访问的账户 MyCount myCount = new MyCount("95599200901215522", 10000); //创建一个线程池 ExecutorService pool = Executors.newFixedThreadPool(2); Thread t1 = new SaveThread("张三", myCount, 2000); Thread t2 = new SaveThread("李四", myCount, 3600); Thread t3 = new DrawThread("王五", myCount, 2700); Thread t4 = new SaveThread("老张", myCount, 600); Thread t5 = new DrawThread("老牛", myCount, 1300); Thread t6 = new DrawThread("胖子", myCount, 800); //执行各个线程 pool.execute(t1); pool.execute(t2); pool.execute(t3); pool.execute(t4); pool.execute(t5); pool.execute(t6); //关闭线程池 pool.shutdown(); } } /** * 存款线程类 */ class SaveThreadextends Thread { private String name; //操作人 private MyCount myCount; //账户 privateint x; //存款金额 SaveThread(String name, MyCount myCount, int x) { this.name = name; this.myCount = myCount; this.x = x; } publicvoid run() { myCount.saving(x, name); } } /** * 取款线程类 */ class DrawThreadextends Thread { private String name; //操作人 private MyCount myCount; //账户 privateint x; //存款金额 DrawThread(String name, MyCount myCount, int x) { this.name = name; this.myCount = myCount; this.x = x; } publicvoid run() { myCount.drawing(x, name); } } /** * 普通银行账户,不可透支 */ class MyCount { private String oid; //账号 privateint cash; //账户余额 private Lock lock =new ReentrantLock(); //账户锁 private Condition _save = lock.newCondition(); //存款条件 private Condition _draw = lock.newCondition(); //取款条件 MyCount(String oid, int cash) { this.oid = oid; this.cash = cash; } /** * 存款 * * @param x 操作金额 * @param name 操作人 */ publicvoid saving(int x, String name) { lock.lock(); //获取锁 if (x > 0) { cash += x; //存款 System.out.println(name + "存款" + x +",当前余额为" + cash); } _draw.signalAll(); //唤醒所有等待线程。 lock.unlock(); //释放锁 } /** * 取款 * * @param x 操作金额 * @param name 操作人 */ publicvoid drawing(int x, String name) { lock.lock(); //获取锁 try { if (cash - x < 0) { _draw.await(); //阻塞取款操作 } else { cash -= x; //取款 System.out.println(name + "取款" + x +",当前余额为" + cash); } _save.signalAll(); //唤醒所有存款操作 } catch (InterruptedException e) { e.printStackTrace(); } finally { lock.unlock(); //释放锁 } } }
运行结果:
李四存款3600,当前余额为13600
张三存款2000,当前余额为15600
老张存款600,当前余额为16200
老牛取款1300,当前余额为14900
胖子取款800,当前余额为14100
王五取款2700,当前余额为11400
Process finished with exit code 0
假如不用锁和条件变量,如何实现此功能?下面是实现代码:
import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; /** * Java线程:不用条件变量 * */ publicclass Test { publicstaticvoid main(String[] args) { //创建并发访问的账户 MyCount myCount = new MyCount("95599200901215522", 10000); //创建一个线程池 ExecutorService pool = Executors.newFixedThreadPool(2); Thread t1 = new SaveThread("张三", myCount, 2000); Thread t2 = new SaveThread("李四", myCount, 3600); Thread t3 = new DrawThread("王五", myCount, 2700); Thread t4 = new SaveThread("老张", myCount, 600); Thread t5 = new DrawThread("老牛", myCount, 1300); Thread t6 = new DrawThread("胖子", myCount, 800); //执行各个线程 pool.execute(t1); pool.execute(t2); pool.execute(t3); pool.execute(t4); pool.execute(t5); pool.execute(t6); //关闭线程池 pool.shutdown(); } } /** * 存款线程类 */ class SaveThreadextends Thread { private String name; //操作人 private MyCount myCount; //账户 privateint x; //存款金额 SaveThread(String name, MyCount myCount, int x) { this.name = name; this.myCount = myCount; this.x = x; } publicvoid run() { myCount.saving(x, name); } } /** * 取款线程类 */ class DrawThreadextends Thread { private String name; //操作人 private MyCount myCount; //账户 privateint x; //存款金额 DrawThread(String name, MyCount myCount, int x) { this.name = name; this.myCount = myCount; this.x = x; } publicvoid run() { myCount.drawing(x, name); } } /** * 普通银行账户,不可透支 */ class MyCount { private String oid; //账号 privateint cash; //账户余额 MyCount(String oid, int cash) { this.oid = oid; this.cash = cash; } /** * 存款 * * @param x 操作金额 * @param name 操作人 */ publicsynchronizedvoid saving(int x, String name) { if (x > 0) { cash += x; //存款 System.out.println(name + "存款" + x +",当前余额为" + cash); } notifyAll(); //唤醒所有等待线程。 } /** * 取款 * * @param x 操作金额 * @param name 操作人 */ publicsynchronizedvoid drawing(int x, String name) { if (cash - x < 0) { try { wait(); } catch (InterruptedException e1) { e1.printStackTrace(); } } else { cash -= x; //取款 System.out.println(name + "取款" + x +",当前余额为" + cash); } notifyAll(); //唤醒所有存款操作 } }
输出结果为:
李四存款3600,当前余额为13600
王五取款2700,当前余额为10900
老张存款600,当前余额为11500
老牛取款1300,当前余额为10200
胖子取款800,当前余额为9400
张三存款2000,当前余额为11400
Process finished with exit code 0
结合先前同步代码知识,举一反三,将此例改为同步代码块来实现,代码如下:
import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; /** * Java线程:改为同步代码块 * */ publicclass Test { publicstaticvoid main(String[] args) { //创建并发访问的账户 MyCount myCount = new MyCount("95599200901215522", 10000); //创建一个线程池 ExecutorService pool = Executors.newFixedThreadPool(2); Thread t1 = new SaveThread("张三", myCount, 2000); Thread t2 = new SaveThread("李四", myCount, 3600); Thread t3 = new DrawThread("王五", myCount, 2700); Thread t4 = new SaveThread("老张", myCount, 600); Thread t5 = new DrawThread("老牛", myCount, 1300); Thread t6 = new DrawThread("胖子", myCount, 800); //执行各个线程 pool.execute(t1); pool.execute(t2); pool.execute(t3); pool.execute(t4); pool.execute(t5); pool.execute(t6); //关闭线程池 pool.shutdown(); } } /** * 存款线程类 */ class SaveThreadextends Thread { private String name; //操作人 private MyCount myCount; //账户 privateint x; //存款金额 SaveThread(String name, MyCount myCount, int x) { this.name = name; this.myCount = myCount; this.x = x; } publicvoid run() { myCount.saving(x, name); } } /** * 取款线程类 */ class DrawThreadextends Thread { private String name; //操作人 private MyCount myCount; //账户 privateint x; //存款金额 DrawThread(String name, MyCount myCount, int x) { this.name = name; this.myCount = myCount; this.x = x; } publicvoid run() { myCount.drawing(x, name); } } /** * 普通银行账户,不可透支 */ class MyCount { private String oid; //账号 privateint cash; //账户余额 MyCount(String oid, int cash) { this.oid = oid; this.cash = cash; } /** * 存款 * * @param x 操作金额 * @param name 操作人 */ publicvoid saving(int x, String name) { if (x > 0) { synchronized (this) { cash += x; //存款 System.out.println(name + "存款" + x +",当前余额为" + cash); notifyAll(); //唤醒所有等待线程。 } } } /** * 取款 * * @param x 操作金额 * @param name 操作人 */ publicsynchronizedvoid drawing(int x, String name) { synchronized (this) { if (cash - x < 0) { try { wait(); } catch (InterruptedException e1) { e1.printStackTrace(); } } else { cash -= x; //取款 System.out.println(name + "取款" + x +",当前余额为" + cash); } } notifyAll(); //唤醒所有存款操作 } }
运行结果:
李四存款3600,当前余额为13600
王五取款2700,当前余额为10900
老张存款600,当前余额为11500
老牛取款1300,当前余额为10200
胖子取款800,当前余额为9400
张三存款2000,当前余额为11400
Process finished with exit code 0