使用Java实现面向对象_第七章_多线程(小结)

7.1  线程概述

计算机的操作系统多采用任务和分时设计，多任务是指在一个操作系统中可以同时运行多个程序。

7.1.1  进程

认识进程先从程序开始，程序(Program)是对数据描述与操作的代码的集合，如Office中的word，暴风影音等应用程序。

进程(Process)是程序的一次动态执行过程，它对应了从代码加载、执行至执行完毕的一个完整过程，这个过程是继承本身从产生、发张至消亡的过程。操作系统同时管理一个计算机系统中的多个进程。让计算机系统中的多个进程轮流使用CPU资源，或者共享操作系统的其他资源。

         进程的特点是：

（1）      进程是系统运行程序的基本单位。

（2）      每一个进程都有自己独立的一块内存空间、一组系统资源。

（3）      每个进程的内部数据和状态都是完全独立的。

7.1.2  线程

         线程是进程中执行运算的最小单位，可完成一个独立的顺序控制流程。每一个进程中，必须至少建立一个线程（这个线程称为主线程）来作为这个程序运行的入口点。如果在一个进程中同时运行多个线程，用来完成不同的工作，则称为“多线程”。

7.1.3  多线程的好处

……(1)资源利用率更好

想象一下，一个应用程序需要从本地文件系统中读取和处理文件的情景。比方说，从磁盘读取一个文件需要5秒，处理一个文件需要2秒。处理两个文件则需要：

1	5秒读取文件A
2	2秒处理文件A

 

3	5秒读取文件B
4	2秒处理文件B

 

5	---------------------
6	总共需要14秒

从磁盘中读取文件的时候，大部分的CPU时间用于等待磁盘去读取数据。在这段时间里，CPU非常的空闲。它可以做一些别的事情。通过改变操作的顺序，就能够更好的使用CPU资源。看下面的顺序：

1	5秒读取文件A
2	5秒读取文件B + 2秒处理文件A

 

3	2秒处理文件B
4	---------------------

 

总共需要12秒

CPU等待第一个文件被读取完。然后开始读取第二个文件。当第二文件在被读取的时候，CPU会去处理第一个文件。记住，在等待磁盘读取文件的时候，CPU大部分时间是空闲的。

总的说来，CPU能够在等待IO的时候做一些其他的事情。这个不一定就是磁盘IO。它也可以是网络的IO，或者用户输入。通常情况下，网络和磁盘的IO比CPU和内存的IO慢的多。

……(2)程序设计更简单

在单线程应用程序中，如果你想编写程序手动处理上面所提到的读取和处理的顺序，你必须记录每个文件读取和处理的状态。相反，你可以启动两个线程，每个线程处理一个文件的读取和操作。线程会在等待磁盘读取文件的过程中被阻塞。在等待的时候，其他的线程能够使用CPU去处理已经读取完的文件。其结果就是，磁盘总是在繁忙地读取不同的文件到内存中。这会带来磁盘和CPU利用率的提升。而且每个线程只需要记录一个文件，因此这种方式也很容易编程实现。

……(3)程序响应更快

将一个单线程应用程序变成多线程应用程序的另一个常见的目的是实现一个响应更快的应用程序。设想一个服务器应用，它在某一个端口监听进来的请求。当一个请求到来时，它去处理这个请求，然后再返回去监听。

服务器的流程如下所述：

1	while(server is active){
2	listen for request

 

3	process request
4	}

如果一个请求需要占用大量的时间来处理，在这段时间内新的客户端就无法发送请求给服务端。只有服务器在监听的时候，请求才能被接收。另一种设计是，监听线程把请求传递给工作者线程(workerthread)，然后立刻返回去监听。而工作者线程则能够处理这个请求并发送一个回复给客户端。这种设计如下所述：

1	while(server is active){
2	listen for request

 

3	hand request to worker thread
4	}

这种方式，服务端线程迅速地返回去监听。因此，更多的客户端能够发送请求给服务端。这个服务也变得响应更快。

桌面应用也是同样如此。如果你点击一个按钮开始运行一个耗时的任务，这个线程既要执行任务又要更新窗口和按钮，那么在任务执行的过程中，这个应用程序看起来好像没有反应一样。相反，任务可以传递给工作者线程（wordthread)。当工作者线程在繁忙地处理任务的时候，窗口线程可以自由地响应其他用户的请求。当工作者线程完成任务的时候，它发送信号给窗口线程。窗口线程便可以更新应用程序窗口，并显示任务的结果。对用户而言，这种具有工作者线程设计的程序显得响应速度更快。

7.2  在Java中实现多线程

         Java在类和几口方面多线程提供内置支持。Java通过Thread类将线程所必须的功能都封装了起来。

7.2.1  Thread类及其常用方法

         Java提供了Java.lang.Thread类支持多线程编程，该类提供了大量的方法来控制和操作线程。如图：

构造方法	说明
Thread( )	分配新的Thread对象
Thread(Runnable target)	分配新的Thread对象，target为run()方法被调用的对象
Thread(Runnable target，String name)	分配新的Thread对象，target为run()方法被调用的对象，name为新线程的名称
Void run()	执行任务操作的方法
Void start()	使该线程开始执行，Java虚拟机调用该线程的run()方法
Void sleep(long millis)	在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）
String getName()	返回线程的名称
Int getPriority()	返回线程的优先级
Void setPriority(int newPriority)	更改线程的优先级
Static Thread currentThread()	返回当前正在执行的线程对象的引用
Boolean isAlive()	测试线程是否处于活动状态
Void join()	等待该线程终止
Void interrupt()	中断线程
Void yield()	暂停当前正在执行的线程对象，并执行其他线程

7.2.2  主线程

         在Java程序启动时，一个线程立刻运行，该线程通常名称为程序的主线程。Java程序中的public static void main()方法是主线的入口，每个进程都至少有一个主线程。他是程序开始时就执行的。主线程的重要性体现在一下两个方面。

（1）      他是产生其他子线程的线程。

（2）      通常他必须最后完成执行，因为他执行各种关闭执行。

开发中，童虎编写的线程一般是指除了主线程之外的其他线程，。使用一个线程的过，可以分为四个步骤：

（1）      定义一个线程，同时指明这个线程所要执行的代码，即期望完成的功能。

（2）      创建线程对象。

（3）      启动线程。

（4）      终止线程。

在Java中，创建线程类有两种方法，一种是继承Thread类，另一种是实现Runnable接口。

7.2.3  继承Thread类创建线程

         因为使用此方法创建线程类，此线程需要继续Thread类并重写Thread类的run()方法。因为Thread类的run()方法是线程要执行操作任务的方法，所以线程要执行的操作代码都需要写在run()方法中，并通过调用start()方法启动线程后调用。

package shili02; /**  * 示例02  * @author Lihui  *  * 2018年4月10日  */    //通过集成Thread类来创建线程 publicclass MyThread extends Thread{     //重写run()方法     publicvoid run()     {        for (int i = 1; i < 100; i++) {            System.out.println(Thread.currentThread().getName() + ":" + i);        }     } }     publicclass Test {     publicstaticvoid main(String[] args) {        MyThread thread = new MyThread();        thread.start();   //启动线程     } }

在实例2测试类的main()方法中在创建一个线程实例并启动。

package shili03; /**  * 测试类  * 示例03  * @author Lihui  *  * 2018年4月10日  */ publicclass Test {     publicstaticvoid main(String[] args) {        MyThread thread = new MyThread();        MyThread thread2 = new MyThread();   //创建新线程thread2        thread.start();        thread2.start();   //启动线程thread2     } }

修改示例3，将直接调用线程实例的run()方法。如示例4。

package shili04; /**  * 测试类  * 示例04  * @author Lihui  *  * 2018年4月10日  */ publicclass Test {     publicstaticvoid main(String[] args) {        MyThread t1 = new MyThread();        MyThread t2 = new MyThread();   //创建新线程thread2        //直接调用方法run()        t1.run();        t2.run();     } }

7.2.4  实现Runnable接口创建线程

         使用继承Thread类的方式创建线程简单明了，符合大家的习惯，但他也有一个缺店，如果定义得类已经继承了其他类，则无法再继承Thread类。

package shili05; /**  * 示例05  * @author Lihui  *  * 2018年4月10日  */ publicclass MyRunnable implements Runnable{     //实现run()方法     publicvoid run()     {        for (int i = 1; i < 100; i++) {            System.out.println(Thread.currentThread().getName() + ":" + i);        }     } }       publicclass Test {     publicstaticvoid main(String[] args) {        MyRunnable myRunnable = new MyRunnable();        Thread myThread = new Thread(myRunnable);        myThread.start();     } }

7.3  线程的状态

         任何线程一般都具有五种状态，即创建、就绪、运行、阻塞、死亡状态。

新建和就绪

程序使用new会新建一个线程，new出的对象跟普通对象一样，JVM会为其分配内存，初始化成员变量等，此时线程并没有运行，而是就是新建状态。

当线程对象调用start后，线程将进入就绪状态。JVM会为其创建函数调度栈和计数器，但此时线程依然没有运行，而是等待获取CPU执行片

下面的例子可以证明当线程对象调用start后，并不一定立即执行，

for(inti=0; i<50; i++) {
    System.out.println(Thread.currentThread().getName()+" "+i);
    if(i==20){
        SecondThread st = newSecondThread();
        newThread(st, "new thread 1").start();
    }
}

上面是在main中创建子线程，下面是运行结果，

...

main 18
main 19
main 20
main 21
main 22
newthread 10
main 23
newthread 11
main 24
newthread 12
main 25

...

从上面的运行结果可以看到，原本在main中i=20的时候新建了一个子线程，并立即调用了start()使线程进入就绪状态，但是一直等到i=22的时候，子线程才开始运行，所以子线程何时会开始执行取决于CPU执行片的分配，由JVM调度器决定。

运行和阻塞状态

当就绪状态的线程获取了CPU执行片的之后，就进入运行状态，但是在执行过程中，可能会因为以下原因使线程进入阻塞状态，

·        CPU执行片已经用完，JVM切换到其他线程执行

·        线程调用sleep()

·        线程调用了阻塞IO方法，该方法返回之前，线程会一直阻塞

·        线程试图获取被其他线程持有的同步监视器

·        线程在等待某个通知

·        程序调用了线程的suspend()将线程挂起。（容易死锁，不推荐）

线程从运行进入阻塞状态之后，接着只能继续阻塞或者再次进入就绪状态，下面情况会使线程由阻塞状态重新进入就绪状态，

·        线程调用的slee()经过了指定时间

·        线程调用的阻塞IO方法返回

·        线程成功获取同步监视器

·        线程收到其他线程发出的通知

·        被挂起(suspend)的线程又被程序调用了resume方法

下图演示了线程状态转换过程，

注意从上图可知，

线程从阻塞状态只能进入就绪状态，

通常情况下，就绪状态和运行状态的转换是不受程序控制的，而是由JVM线程调度机制控制的

yield()方法可以让运行状态的线程进入就绪状态

线程死亡

线程结束后就处于死亡状态，线程会以如下三种方式结束，

·        run()或call()正常执行完成，线程正常结束

·        线程抛出一个未捕获的Exception或Error

·        直接调用线程的stop()方法结束线程，容易死锁

注意，子线程一旦启动，其地位和主线程是一样的，所以一旦主线程结束了，子线程不会受影响，不会跟着结束

线程对象的isAlive()方法在就绪，运行，阻塞时返回true，在新建，死亡时返回false

对已经死亡的线程调用start()是无效的，会抛出异常。死亡的线程不可再次作为线程来执行。

对于新建的线程，调用两次start()方法也会抛出异常

7.4  线程的调度

         在单CPU的计算机中，一个时刻只有一个线程进行，所谓多线程的并发运行，其实是指从宏观上看，各个线程轮流获得CPU资源的使用权，分别执行各自的任务。Java虚拟机的一项任务就是负责线程的调度，线程调度是指按照特定机制多个线程分配CPU的使用权。

7.4.1  线程的优先级

1.在任意时刻，当有多个线程处于可运行状态时，运行系统总是挑选一个优先级最高的线程执行，只有当线程停止、退出或者由于某些原因不执行的时候，低优先级的线程才可能被执行

2.两个优先级相同的线程同时等待执行时，那么运行系统会以round-robin的方式选择一个线程执行（即轮询调度，以该算法所定的）（Java的优先级策略是抢占式调度！）

3.被选中的线程可因为一下原因退出，而给其他线程执行的机会：

1) 一个更高优先级的线程处于可运行状态（Runnable）

2）线程主动退出（yield），或它的run方法结束

3）在支持分时方式的系统上，分配给该线程的时间片结束

4.Java运行系统的线程调度算法是抢占式（preemptive）的，当更高优先级的线程出现并处于Runnable状态时，运行系统将选择高优先级的线程执行

5.例外地，当高优先级的线程处于阻塞状态且CPU处于空闲时，低优先级的线程也会被调度执行

 1publicclass PriorityExample{

 2     publicstaticvoid main(Strinig[] args){

 3         Thread a = new PThread("A");

 4         Thread b = new PThread("B");

 5         a.setPriority(7); //设置优先级

 6         a.setPriority(1);

 7     }

 8 }

 9

10class PThread extends Thread{

11     public PThread(String n){

12         super(n);

13     }

14

15     publicvoid run(){

16         for(int i=0; i<5000000; i++){

17             if(i%5000000 == 0){

18                 System.out.print(getName());

19             }

20         }

21     }

22 }

 

输出 AAAAAAAAABBBBBBBBB

 

 

利己线程

---

 

1.一般地，在线程中可以调用sleep方法，放弃当前线程对处理器的使用，从而使各个线程均有机会得到执行，但有时候线程可能不遵循这个规则！

1publicvoid run(){

2     for(int i=0; i<5000000; i++){

3         if(i%5000000 == 0){

4             System.out.print(getName());

5         }

6     }

7 }

 

2.for循环是一个紧密循环，一旦运行系统选择了有for循环体的线程执行，该线程就不会放弃对处理器的使用权，除非for循环自然终止或者该线程被一个有更高优先级的线程抢占，这样的线程称为利己线程

3.利己线程一般不引起问题，但有时会让其他的线程得到处理器使用权之前等待一段很长的时间

 

 

分时方式

---

 

1.为解决利己线程可能长时间占据CPU的问题，有些系统通过分时方式来限制利己线程的执行，如Windows2000或WindowsNT系统

2.在分时方式中，处理器的分配按照时间片来划分，对于那些具有相同最高优先级的多个线程，分时技术会交替地分配CPU时间片给他们执行，当时间片结束，即使该线程没有运行结束，也会让出CPU使用权

3.注释掉优先级设置后，输出变成了AAAAABBBBBAAABBB或者AABBAAAABBBBAABBA

 1 publicclass PriorityExample{

 2     publicstaticvoid main(Strinig[] args){

 3         Thread a = new PThread("A");

 4         Thread b = new PThread("B");

 5         //a.setPriority(7); //设置优先级

 6         //a.setPriority(1);

 7     }

 8 }

 9 

10 class PThread extends Thread{

11     public PThread(String n){

12         super(n);

13     }

14 

15     publicvoid run(){

16         for(int i=0; i<5000000; i++){

17             if(i%5000000 == 0){

18                 System.out.print(getName());

19             }

20         }

21     }

22 } 

 

而如果在另一个不支持分时技术的平台上运行程序，得到的输出结果可能是确定的！ AAAAAAAAABBBBBBBBB

 

4.Java运行系统不实现分时，分时是和平台相关的，而有的平台不支持分时，在编写Java多线程程序的时候，不能过分依赖分时技术来保证各个线程都有公平的执行机会！通常应编写那种可以主动放弃处理器使用权的程序，同时一个线程也可以调用yield方法主动放弃对处理器的使用权

　　注意：使用yield只能给同优先级的线程提供执行机会，如果没有同优先级的线程处于可运行状态，yield方法将被忽略！

7.4.2  线程的休眠

一、sleep()介绍

sleep() 定义在Thread.java中。
sleep() 的作用是让当前线程休眠，即当前线程会从“运行状态”进入到“休眠(阻塞)状态”。sleep()会指定休眠时间，线程休眠的时间会大于/等于该休眠时间；在线程重新被唤醒时，它会由“阻塞状态”变成“就绪状态”，从而等待cpu的调度执行。

二、sleep()示例

下面通过一个简单示例演示sleep()的用法。

package com.demo.sleep;

 

publicclass ThreadA extends Thread{

   

     public ThreadA(String name){

         super(name);

     }

    

     publicsynchronizedvoid run() {

        try {

            for(int i=0; i <10; i++){

                System.out.printf("%s:%d\n", this.getName(), i);

                // i能被4整除时，休眠100毫秒

                if (i%4 == 0)

                    Thread.sleep(100);

            }

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

    }

}

package com.demo.sleep;

 

publicclass SleepTest {

   

    publicstaticvoid main(String[] args){

        ThreadA t1 = new ThreadA("t1");

        t1.start();

    }

}

运行结果：

t1: 0

t1: 1

t1: 2

t1: 3

t1: 4

t1: 5

t1: 6

t1: 7

t1: 8

t1: 9

结果说明：
程序比较简单，在主线程main中启动线程t1。t1启动之后，当t1中的计算i能被4整除时，t1会通过Thread.sleep(100)休眠100毫秒。

三、sleep()与wait()的比较

     我们知道，wait()的作用是让当前线程由“运行状态”进入“等待(阻塞)状态”的同时，也会释放同步锁。而sleep()的作用是也是让当前线程由“运行状态”进入到“休眠(阻塞)状态”。但是，wait()会释放对象的同步锁，而sleep()则不会释放锁。

下面通过示例演示sleep()是不会释放锁的。

package com.demo.sleep;

 

publicclass ThreadB extends Thread{

    

     privatestatic Object obj = new Object();

    

     public ThreadB(String name){

         super(name);

     }

    

     publicvoid run(){

         synchronized(obj){

             try {

                 for(int i=0; i <10; i++){

                    System.out.printf("%s: %d\n", this.getName(), i);

                     // i能被4整除时，休眠100毫秒

                     if (i%4 == 0)

                         Thread.sleep(100);

                 }

             } catch (InterruptedException e) {

                 e.printStackTrace();

             }

         }

     }

}

package com.demo.sleep;

 

publicclass SleepLockTest {

   

     publicstaticvoid main(String[] args){

        

         ThreadB t1 = new ThreadB("t1");

         ThreadB t2 = new ThreadB("t2");

         t1.start();

         t2.start();

     }

}

运行结果：

t1: 0

t1: 1

t1: 2

t1: 3

t1: 4

t1: 5

t1: 6

t1: 7

t1: 8

t1: 9

t2: 0

t2: 1

t2: 2

t2: 3

t2: 4

t2: 5

t2: 6

t2: 7

t2: 8

t2: 9

结果说明：
主线程main中启动了两个线程t1和t2。t1和t2在run()会引用同一个对象的同步锁，即synchronized(obj)。在t1运行过程中，虽然它会调用Thread.sleep(100)；但是，t2是不会获取cpu执行权的。因为，t1并没有释放“obj所持有的同步锁”！
注意，若我们注释掉synchronized (obj)后再次执行该程序，t1和t2是可以相互切换的。下面是注释调synchronized(obj)之后的源码：

package com.demo.sleep;

 

publicclass ThreadB extends Thread{

    

     privatestatic Object obj = new Object();

    

     public ThreadB(String name){

         super(name);

     }

    

     publicvoid run(){

         //synchronized(obj){

             try {

                 for(int i=0; i <10; i++){

                    System.out.printf("%s: %d\n", this.getName(), i);

                     // i能被4整除时，休眠100毫秒

                     if (i%4 == 0)

                         Thread.sleep(100);

                 }

             } catch (InterruptedException e) {

                 e.printStackTrace();

             }

         //}

     }

}

再次运行SleepLockTest.java，结果如下：

t1: 0

t2: 0

t2: 1

t2: 2

t1: 1

t1: 2

t2: 3

t1: 3

t2: 4

t1: 4

t1: 5

t1: 6

t1: 7

t1: 8

t2: 5

t2: 6

t2: 7

t2: 8

t1: 9

t2: 9

7.4.3  线程的强制运行

Java终止正在运行的线程的方式有如下三种

·        1 使用退出标志，使线程正常退出，也就是run方法完成后线程终止

·        2 使用stop方法强行终止线程（已过时），但是不推荐使用这个方法

·        3 使用interrupt方法中断线程

1 使用退出标志，使线程正常退出，也就是run方法完成后线程终止

当run方法正常执行完，线程也就停止了，当有循环时，可设置一个标志变量，为真时运行，否则退出循环，主要代码如下：

publicvoidrun() {

    while(flag){

        //do something

    }

}

想要终止运行时，只需设置flag值为false即可。

2 使用stop方法强行终止线程（已过时）

使用stop()方法能立即停止线程，但是可能使一些请理性工作得不到完成。另一种情况就是对锁锁定的对象经行了“解锁”，导致数据得不到同步的处理，出现不一致的问题

3 使用interrupt方法中断线程

值得注意的是，interrupt()方法并不能真正停止线程，而是在当前线程打了一个停止的标记，可用以下方法停止线程。

publicvoidrun() {

        while (true) {

            if (this.interrupted())

                break;

            System.out.println("running");

        }

        System.out.println("退出线程");

调用interrupt()方法，this.interrupted()结果为true，退出循环，但会继续执行System.out.println(“退出线程”);然后正常退出线程。可以采用抛异常的方式终止线程，代码如下

publicvoidrun() {

    try {

        while (true) {

            if (this.interrupted()) {

                thrownew InterruptedException();

            }

            System.out.println("running");

        }

    } catch (InterruptedException e) {

        e.printStackTrace();

    }

}

7.4.4  线程的礼让

         Yield()方法定义的语法如下：

public static void yield()

Yield()方法课暂停当前线程执行，允许其他具有相同优先级的线程获得运行机会，该线程任处于就绪状态，不转为阻塞状态，此时，系统选择其他相同或更高优先级程执行，若无其他相同或更高优先级线程，则该线程继续执行。

package shili10; /**  * 示例10  * @author Lihui  *  * 2018年4月10日  */ publicclass MyThread implements Runnable{     publicvoid run()     {        for (int i = 0; i < 5; i++) {            System.out.println(Thread.currentThread().getName() + "正在运行" + i);            if (i == 3) {               System.out.println("线程礼让");               Thread.yield();            }        }     } }       publicclass ThreadYieldDemo {     publicstaticvoid main(String[] args) {        Mythread my = new Mythread();        Thread t1 = new Thread(my,"线程A");        Thread t2 = new Thread(my,"线程B");        t1.start();     } }

7.5  线程的同步

7.5.2  线程同步的实现

同步的方法：

一、同步方法

　　即有synchronized关键字修饰的方法。 由于java的每个对象都有一个内置锁，当用此关键字修饰方法时， 内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。

注：synchronized关键字也可以修饰静态方法，此时如果调用该静态方法，将会锁住整个类。

 

二、同步代码块

　　即有synchronized关键字修饰的语句块。 被该关键字修饰的语句块会自动被加上内置锁，从而实现同步

    代码如： 

synchronized(object){

}

   注：同步是一种高开销的操作，因此应该尽量减少同步的内容。通常没有必要同步整个方法，使用synchronized代码块同步关键代码即可。 

    package com.xhj.thread;

 

    /**

     * 线程同步的运用

     *

     * @author XIEHEJUN

     *

     */

    publicclassSynchronizedThread {

 

        class Bank {

            privateint account = 100;

            publicint getAccount() {

                return account;

            }

 

            /**

             * 用同步方法实现

             *

             * @param money

             */

            publicsynchronizedvoid save(int money) {

                account += money;

            }

 

            /**

             * 用同步代码块实现

             *

             * @param money

             */

            publicvoid save1(int money) {

                synchronized (this) {

                    account += money;

                }

            }

        }

class NewThread implements Runnable {

            private Bank bank;

 

            public NewThread(Bankbank) {

                this.bank = bank;

            }

 

            @Override

            publicvoid run() {

                for (int i = 0; i < 10;i++) {

                    // bank.save1(10);

                    bank.save(10);

                   System.out.println(i + "账户余额为：" +bank.getAccount());

                }

            }

 

        }

 

        /**

         * 建立线程，调用内部类

         */

        publicvoid useThread() {

            Bank bank = new Bank();

            NewThread new_thread = new NewThread(bank);

           System.out.println("线程1");

            Thread thread1 = newThread(new_thread);

            thread1.start();

           System.out.println("线程2");

            Thread thread2 = newThread(new_thread);

            thread2.start();

        }

 

        publicstaticvoid main(String[]args) {

            SynchronizedThread st = newSynchronizedThread();

            st.useThread();

        }

 

    }

 

 

        

=====================================

示例加讲解

同步是多线程中的重要概念。同步的使用可以保证在多线程运行的环境中，程序不会产生设计之外的错误结果。同步的实现方式有两种，同步方法和同步块，这两种方式都要用到synchronized关键字。

同步方法:给一个方法增加synchronized修饰符之后就可以使它成为同步方法，这个方法可以是静态方法和非静态方法，但是不能是抽象类的抽象方法，也不能是接口中的接口方法。下面代码是一个同步方法的示例：

publicsynchronizedvoid aMethod() {

    // do something

}

 

publicstaticsynchronizedvoid anotherMethod() {

    // do something

}

线程在执行同步方法时是具有排它性的。当任意一个线程进入到一个对象的任意一个同步方法时，这个对象的所有同步方法都被锁定了，在此期间，其他任何线程都不能访问这个对象的任意一个同步方法，直到这个线程执行完它所调用的同步方法并从中退出，从而导致它释放了该对象的同步锁之后。在一个对象被某个线程锁定之后，其他线程是可以访问这个对象的所有非同步方法的。

同步块：同步块是通过锁定一个指定的对象，来对同步块中包含的代码进行同步；而同步方法是对这个方法块里的代码进行同步，而这种情况下锁定的对象就是同步方法所属的主体对象自身。如果这个方法是静态同步方法呢？那么线程锁定的就不是这个类的对象了，也不是这个类自身，而是这个类对应的java.lang.Class类型的对象。同步方法和同步块之间的相互制约只限于同一个对象之间，所以静态同步方法只受它所属类的其它静态同步方法的制约，而跟这个类的实例（对象）没有关系。

如果一个对象既有同步方法，又有同步块，那么当其中任意一个同步方法或者同步块被某个线程执行时，这个对象就被锁定了，其他线程无法在此时访问这个对象的同步方法，也不能执行同步块。

synchronized 关键字用于保护共享数据。请大家注意“共享数据”，你一定要分清哪些数据是共享数据，请看下面的例子：

publicclass ThreadTest implements Runnable{

 

publicsynchronizedvoid run(){

for(int i=0;i<10;i++) {

System.out.print(" " + i);

}

}

 

publicstaticvoid main(String[] args) {

Runnable r1 = new ThreadTest(); //也可写成ThreadTest r1 = new ThreadTest();

Runnable r2 = new ThreadTest();

Thread t1 = new Thread(r1);

Thread t2 = new Thread(r2);

t1.start();

t2.start();

}}

 

在这个程序中，run()虽然被加上了synchronized 关键字，但保护的不是共享数据。因为这个程序中的t1,t2 是两个对象（r1,r2）的线程。而不同的对象的数据是不同的，r1,r2 有各自的run()方法，所以输出结果无法预知。

synchronized的目的是使同一个对象的多个线程，在某个时刻只有其中的一个线程可以访问这个对象的synchronized 数据。每个对象都有一个“锁标志”，当这个对象的一个线程访问这个对象的某个synchronized 数据时，这个对象的所有被synchronized 修饰的数据将被上锁（因为“锁标志”被当前线程拿走了），只有当前线程访问完它要访问的synchronized 数据时，当前线程才会释放“锁标志”，这样同一个对象的其它线程才有机会访问synchronized 数据。

示例3：

publicclass ThreadTest implements Runnable{

 

publicsynchronizedvoid run(){

for(int i=0;i<10;i++){

System.out.print(" " + i);

}

}

 

publicstaticvoid main(String[] args){

Runnable r = new ThreadTest();

Thread t1 = new Thread(r);

Thread t2 = new Thread(r);

t1.start();

t2.start();

}}

 

如果你运行1000 次这个程序，它的输出结果也一定每次都是：0 1 2 3 4 5 67 8 9 0 1 2 3 4 5 6 7 8 9。因为这里的synchronized 保护的是共享数据。t1,t2 是同一个对象（r）的两个线程，当其中的一个线程（例如：t1）开始执行run()方法时，由于run()受synchronized保护，所以同一个对象的其他线程（t2）无法访问synchronized 方法（run 方法）。只有当t1执行完后t2 才有机会执行。

示例4：

publicclass ThreadTest implements Runnable{

 

publicvoid run(){

 

    synchronized(this){

    for(int i=0;i<10;i++){

        System.out.print("" + i);

    }

}

}

 

publicstaticvoid main(String[] args){

    Runnable r = new ThreadTest();

    Thread t1 = new Thread(r);

    Thread t2 = new Thread(r);

    t1.start();

    t2.start();

}

}   

 

这个程序与示例3 的运行结果一样。在可能的情况下，应该把保护范围缩到最小，可以用示例4 的形式，this 代表“这个对象”。没有必要把整个run()保护起来，run()中的代码只有一个for循环，所以只要保护for 循环就可以了。

示例5：

publicclass ThreadTest implements Runnable{

 

publicvoid run(){

for(int k=0;k<5;k++){

System.out.println(Thread.currentThread().getName()+" : for loop : " + k);

}

 

synchronized(this){

for(int k=0;k<5;k++) {

System.out.println(Thread.currentThread().getName()+" : synchronized for loop : " + k);

}} }

 

publicstaticvoid main(String[] args){

Runnable r = new ThreadTest();

Thread t1 = newThread(r,"t1_name");

Thread t2 = newThread(r,"t2_name");

t1.start();

t2.start();

} }

 

运行结果：

t1_name : for loop: 0

t1_name : for loop: 1

t1_name : for loop: 2

t2_name : for loop: 0

t1_name : for loop: 3

t2_name : for loop: 1

t1_name : for loop: 4

t2_name : for loop: 2

t1_name :synchronized for loop : 0

t2_name : for loop: 3

t1_name :synchronized for loop : 1

t2_name : for loop: 4

t1_name :synchronized for loop : 2

t1_name : synchronizedfor loop : 3

t1_name :synchronized for loop : 4

t2_name :synchronized for loop : 0

t2_name :synchronized for loop : 1

t2_name :synchronized for loop : 2

t2_name :synchronized for loop : 3

t2_name :synchronized for loop : 4

第一个for 循环没有受synchronized 保护。对于第一个for 循环，t1,t2 可以同时访问。运行结果表明t1 执行到了k=2 时，t2 开始执行了。t1 首先执行完了第一个for 循环，此时t2还没有执行完第一个for 循环（t2 刚执行到k=2）。t1 开始执行第二个for 循环，当t1的第二个for 循环执行到k=1 时，t2 的第一个for 循环执行完了。t2 想开始执行第二个for 循环，但由于t1 首先执行了第二个for 循环，这个对象的锁标志自然在t1 手中（synchronized 方法的执行权也就落到了t1 手中），在t1 没执行完第二个for 循环的时候，它是不会释放锁标志的。所以t2 必须等到t1 执行完第二个for 循环后，它才可以执行第二个for 循环。

=====================================

三、wait与notify

wait():使一个线程处于等待状态，并且释放所持有的对象的lock。

sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。
notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。
Allnotity():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。

详细见：wait、notify、notifyAll的使用方法

四、使用特殊域变量(volatile)实现线程同步

    a.volatile关键字为域变量的访问提供了一种免锁机制

    b.使用volatile修饰域相当于告诉虚拟机该域可能会被其他线程更新

    c.因此每次使用该域就要重新计算，而不是使用寄存器中的值 

    d.volatile不会提供任何原子操作，它也不能用来修饰final类型的变量 

    

    例如： 

        在上面的例子当中，只需在account前面加上volatile修饰，即可实现线程同步。 

    

    代码实例： 

 

        //只给出要修改的代码，其余代码与上同

        class Bank {

            //需要同步的变量加上volatile

            privatevolatileint account = 100;

 

            publicint getAccount() {

                return account;

            }

            //这里不再需要synchronized

            publicvoid save(int money) {

                account += money;

            }

        ｝

    注：多线程中的非同步问题主要出现在对域的读写上，如果让域自身避免这个问题，则就不需要修改操作该域的方法。 

    用final域，有锁保护的域和volatile域可以避免非同步的问题。 

五、使用重入锁实现线程同步

    在JavaSE5.0中新增了一个java.util.concurrent包来支持同步。 

    ReentrantLock类是可重入、互斥、实现了Lock接口的锁，它与使用synchronized方法和快具有相同的基本行为和语义，并且扩展了其能力。

 ReenreantLock类的常用方法有：

ReentrantLock() : 创建一个ReentrantLock实例

lock() : 获得锁

unlock() : 释放锁

注：ReentrantLock()还有一个可以创建公平锁的构造方法，但由于能大幅度降低程序运行效率，不推荐使用 

        

    例如： 

        在上面例子的基础上，改写后的代码为: 

       //只给出要修改的代码，其余代码与上同

        class Bank {

           

            privateint account = 100;

            //需要声明这个锁

            private Lock lock = new ReentrantLock();

            publicint getAccount() {

                return account;

            }

            //这里不再需要synchronized

            publicvoid save(int money) {

                lock.lock();

                try{

                    account +=money;

                }finally{

                    lock.unlock();

                }

               

            }

        ｝

   注：关于Lock对象和synchronized关键字的选择： 

        a.最好两个都不用，使用一种java.util.concurrent包提供的机制，能够帮助用户处理所有与锁相关的代码。 

        b.如果synchronized关键字能满足用户的需求，就用synchronized，因为它能简化代码 

        c.如果需要更高级的功能，就用ReentrantLock类，此时要注意及时释放锁，否则会出现死锁，通常在finally代码释放锁 

 

六、使用局部变量实现线程同步

    如果使用ThreadLocal管理变量，则每一个使用该变量的线程都获得该变量的副本，副本之间相互独立，这样每一个线程都可以随意修改自己的变量副本，而不会对其他线程产生影响。

     ThreadLocal 类的常用方法

ThreadLocal() : 创建一个线程本地变量

get() : 返回此线程局部变量的当前线程副本中的值

initialValue() : 返回此线程局部变量的当前线程的"初始值"

set(T value) : 将此线程局部变量的当前线程副本中的值设置为value

    例如： 

        在上面例子基础上，修改后的代码为： 

        //只改Bank类，其余代码与上同

        publicclass Bank{

            //使用ThreadLocal类管理共享变量account

            privatestaticThreadLocal<Integer> account = newThreadLocal<Integer>(){

                @Override

                protected IntegerinitialValue(){

                    return 100;

                }

            };

            publicvoid save(int money){

               account.set(account.get()+money);

            }

            publicint getAccount(){

                return account.get();

            }

        }

    注：ThreadLocal与同步机制 

        a.ThreadLocal与同步机制都是为了解决多线程中相同变量的访问冲突问题。 

        b.前者采用以"空间换时间"的方法，后者采用以"时间换空间"的方式

 

七、使用阻塞队列实现线程同步

前面5种同步方式都是在底层实现的线程同步，但是我们在实际开发当中，应当尽量远离底层结构。使用javaSE5.0版本中新增的java.util.concurrent包将有助于简化开发。本小节主要是使用LinkedBlockingQueue<E>来实现线程的同步 LinkedBlockingQueue<E>是一个基于已连接节点的，范围任意的blocking queue。 队列是先进先出的顺序（FIFO），关于队列以后会详细讲解~LinkedBlockingQueue 类常用方法 LinkedBlockingQueue(): 创建一个容量为Integer.MAX_VALUE的LinkedBlockingQueueput(E e) : 在队尾添加一个元素，如果队列满则阻塞 size() : 返回队列中的元素个数 take() : 移除并返回队头元素，如果队列空则阻塞代码实例： 实现商家生产商品和买卖商品的同步

 

注：BlockingQueue<E>定义了阻塞队列的常用方法，尤其是三种添加元素的方法，我们要多加注意，当队列满时：

　　add()方法会抛出异常

　　offer()方法返回false

　　put()方法会阻塞

 

 

7.使用原子变量实现线程同步

 

需要使用线程同步的根本原因在于对普通变量的操作不是原子的。

那么什么是原子操作呢？原子操作就是指将读取变量值、修改变量值、保存变量值看成一个整体来操作即-这几种行为要么同时完成，要么都不完成。在java的util.concurrent.atomic包中提供了创建了原子类型变量的工具类，使用该类可以简化线程同步。其中AtomicInteger 表可以用原子方式更新int的值，可用在应用程序中(如以原子方式增加的计数器)，但不能用于替换Integer；可扩展Number，允许那些处理机遇数字类的工具和实用工具进行统一访问。

AtomicInteger类常用方法：

AtomicInteger(intinitialValue) : 创建具有给定初始值的新的

AtomicIntegeraddAddGet(intdalta) : 以原子方式将给定值与当前值相加

get() : 获取当前值

代码实例：

只改Bank类，其余代码与上面第一个例子同

class Bank {

    private AtomicIntegeraccount = new AtomicInteger(100);

    public AtomicIntegergetAccount() {

        return account;

    }

    publicvoid save(int money) {

        account.addAndGet(money);

    }

}

7.5.3  线程安全的类型

在使用多线程时，就不得不考虑线程安全问题了。对于int，long 这种基本类型，是不具有线程安全的，所以就特别期望能有一种线程安全的基本类型，类似使用redis 那样，在多线程中也丝毫不用考虑多线程问题。最近，突然发现了原来java 也自带了线程安全的基本类型，包括： AtomicInteger,AtomicLong, AtomicBoolean, AtomicIntegerArray,AtomicLongArray; 等，感觉实在是太棒了。

 

1. 测试代码

[java]viewplaincopy

1.  package org.zgf.test;  

2.    

3.  import java.util.concurrent.atomic.AtomicInteger;  

4.    

5.  public class TestAtomic {  

6.    

7.      public static void main(String[] args) {  

8.          AtomicInteger atomicInteger = new AtomicInteger(1);  

9.            

10.          int number = 0;  

11.            

12.          //getAndAdd: 先获取值，再自增10，返回值为自增前的值  

13.          number = atomicInteger.getAndAdd(10);  

14.          System.out.println("getAndAdd       --> number:" + number + ", atomicInteger: " + atomicInteger);  

15.            

16.          //getAndDecrement: 先获得值，再自减1，返回值为自减前的  

17.          number = atomicInteger.getAndDecrement();  

18.          System.out.println("getAndDecrement --> number:" + number + ", atomicInteger: " + atomicInteger);  

19.            

20.          //getAndIncrement: 先获得值，再自增1，返回值为自增前的值  

21.          number = atomicInteger.getAndIncrement();  

22.          System.out.println("getAndIncrement --> number:" + number + ", atomicInteger: " + atomicInteger);  

23.            

24.          //getAndSet: 先获得值,再赋值，返回值为赋值前的值  

25.          number = atomicInteger.getAndSet(10);  

26.          System.out.println("getAndSet       --> number:" + number + ", atomicInteger: " + atomicInteger);  

27.            

28.          //addAndGet: 先自增，再返回值，返回值为自增后的值  

29.          number = atomicInteger.addAndGet(10);  

30.          System.out.println("addAndGet       --> number:" + number + ", atomicInteger: " + atomicInteger);  

31.            

32.          //decrementAndGet: 先自减1，再获取返回值，返回值为自减后的值  

33.          number = atomicInteger.decrementAndGet();  

34.          System.out.println("decrementAndGet --> number:" + number + ", atomicInteger: " + atomicInteger);  

35.            

36.          //incrementAndGet: 先自增1，再返回值，返回值为自增后的值  

37.          number = atomicInteger.incrementAndGet();  

38.          System.out.println("incrementAndGet --> number:" + number + ", atomicInteger: " + atomicInteger);  

39.            

40.          //compareAndSet: 如果当前值为20，则设置为100  

41.          boolean isSuccess = atomicInteger.compareAndSet(20, 100);  

42.          System.out.println("compareAndSet: " + isSuccess);  

43.            

44.      }  

45.  }  

7.1  线程概述

计算机的操作系统多采用任务和分时设计，多任务是指在一个操作系统中可以同时运行多个程序。

7.1.1  进程

认识进程先从程序开始，程序(Program)是对数据描述与操作的代码的集合，如Office中的word，暴风影音等应用程序。

进程(Process)是程序的一次动态执行过程，它对应了从代码加载、执行至执行完毕的一个完整过程，这个过程是继承本身从产生、发张至消亡的过程。操作系统同时管理一个计算机系统中的多个进程。让计算机系统中的多个进程轮流使用CPU资源，或者共享操作系统的其他资源。

         进程的特点是：

（1）      进程是系统运行程序的基本单位。

（2）      每一个进程都有自己独立的一块内存空间、一组系统资源。

（3）      每个进程的内部数据和状态都是完全独立的。

7.1.2  线程

         线程是进程中执行运算的最小单位，可完成一个独立的顺序控制流程。每一个进程中，必须至少建立一个线程（这个线程称为主线程）来作为这个程序运行的入口点。如果在一个进程中同时运行多个线程，用来完成不同的工作，则称为“多线程”。

7.1.3  多线程的好处

……(1)资源利用率更好

想象一下，一个应用程序需要从本地文件系统中读取和处理文件的情景。比方说，从磁盘读取一个文件需要5秒，处理一个文件需要2秒。处理两个文件则需要：

1	5秒读取文件A
2	2秒处理文件A

 

3	5秒读取文件B
4	2秒处理文件B

 

5	---------------------
6	总共需要14秒

从磁盘中读取文件的时候，大部分的CPU时间用于等待磁盘去读取数据。在这段时间里，CPU非常的空闲。它可以做一些别的事情。通过改变操作的顺序，就能够更好的使用CPU资源。看下面的顺序：

1	5秒读取文件A
2	5秒读取文件B + 2秒处理文件A

 

3	2秒处理文件B
4	---------------------

 

总共需要12秒

CPU等待第一个文件被读取完。然后开始读取第二个文件。当第二文件在被读取的时候，CPU会去处理第一个文件。记住，在等待磁盘读取文件的时候，CPU大部分时间是空闲的。

总的说来，CPU能够在等待IO的时候做一些其他的事情。这个不一定就是磁盘IO。它也可以是网络的IO，或者用户输入。通常情况下，网络和磁盘的IO比CPU和内存的IO慢的多。

……(2)程序设计更简单

在单线程应用程序中，如果你想编写程序手动处理上面所提到的读取和处理的顺序，你必须记录每个文件读取和处理的状态。相反，你可以启动两个线程，每个线程处理一个文件的读取和操作。线程会在等待磁盘读取文件的过程中被阻塞。在等待的时候，其他的线程能够使用CPU去处理已经读取完的文件。其结果就是，磁盘总是在繁忙地读取不同的文件到内存中。这会带来磁盘和CPU利用率的提升。而且每个线程只需要记录一个文件，因此这种方式也很容易编程实现。

……(3)程序响应更快

将一个单线程应用程序变成多线程应用程序的另一个常见的目的是实现一个响应更快的应用程序。设想一个服务器应用，它在某一个端口监听进来的请求。当一个请求到来时，它去处理这个请求，然后再返回去监听。

服务器的流程如下所述：

1	while(server is active){
2	listen for request

 

3	process request
4	}

如果一个请求需要占用大量的时间来处理，在这段时间内新的客户端就无法发送请求给服务端。只有服务器在监听的时候，请求才能被接收。另一种设计是，监听线程把请求传递给工作者线程(workerthread)，然后立刻返回去监听。而工作者线程则能够处理这个请求并发送一个回复给客户端。这种设计如下所述：

1	while(server is active){
2	listen for request

 

3	hand request to worker thread
4	}

这种方式，服务端线程迅速地返回去监听。因此，更多的客户端能够发送请求给服务端。这个服务也变得响应更快。

桌面应用也是同样如此。如果你点击一个按钮开始运行一个耗时的任务，这个线程既要执行任务又要更新窗口和按钮，那么在任务执行的过程中，这个应用程序看起来好像没有反应一样。相反，任务可以传递给工作者线程（wordthread)。当工作者线程在繁忙地处理任务的时候，窗口线程可以自由地响应其他用户的请求。当工作者线程完成任务的时候，它发送信号给窗口线程。窗口线程便可以更新应用程序窗口，并显示任务的结果。对用户而言，这种具有工作者线程设计的程序显得响应速度更快。

7.2  在Java中实现多线程

         Java在类和几口方面多线程提供内置支持。Java通过Thread类将线程所必须的功能都封装了起来。

7.2.1  Thread类及其常用方法

         Java提供了Java.lang.Thread类支持多线程编程，该类提供了大量的方法来控制和操作线程。如图：

构造方法	说明
Thread( )	分配新的Thread对象
Thread(Runnable target)	分配新的Thread对象，target为run()方法被调用的对象
Thread(Runnable target，String name)	分配新的Thread对象，target为run()方法被调用的对象，name为新线程的名称
Void run()	执行任务操作的方法
Void start()	使该线程开始执行，Java虚拟机调用该线程的run()方法
Void sleep(long millis)	在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）
String getName()	返回线程的名称
Int getPriority()	返回线程的优先级
Void setPriority(int newPriority)	更改线程的优先级
Static Thread currentThread()	返回当前正在执行的线程对象的引用
Boolean isAlive()	测试线程是否处于活动状态
Void join()	等待该线程终止
Void interrupt()	中断线程
Void yield()	暂停当前正在执行的线程对象，并执行其他线程

7.2.2  主线程

         在Java程序启动时，一个线程立刻运行，该线程通常名称为程序的主线程。Java程序中的public static void main()方法是主线的入口，每个进程都至少有一个主线程。他是程序开始时就执行的。主线程的重要性体现在一下两个方面。

（1）      他是产生其他子线程的线程。

（2）      通常他必须最后完成执行，因为他执行各种关闭执行。

开发中，童虎编写的线程一般是指除了主线程之外的其他线程，。使用一个线程的过，可以分为四个步骤：

（1）      定义一个线程，同时指明这个线程所要执行的代码，即期望完成的功能。

（2）      创建线程对象。

（3）      启动线程。

（4）      终止线程。

在Java中，创建线程类有两种方法，一种是继承Thread类，另一种是实现Runnable接口。

7.2.3  继承Thread类创建线程

         因为使用此方法创建线程类，此线程需要继续Thread类并重写Thread类的run()方法。因为Thread类的run()方法是线程要执行操作任务的方法，所以线程要执行的操作代码都需要写在run()方法中，并通过调用start()方法启动线程后调用。

package shili02; /**  * 示例02  * @author Lihui  *  * 2018年4月10日  */    //通过集成Thread类来创建线程 publicclass MyThread extends Thread{     //重写run()方法     publicvoid run()     {        for (int i = 1; i < 100; i++) {            System.out.println(Thread.currentThread().getName() + ":" + i);        }     } }     publicclass Test {     publicstaticvoid main(String[] args) {        MyThread thread = new MyThread();        thread.start();   //启动线程     } }

在实例2测试类的main()方法中在创建一个线程实例并启动。

package shili03; /**  * 测试类  * 示例03  * @author Lihui  *  * 2018年4月10日  */ publicclass Test {     publicstaticvoid main(String[] args) {        MyThread thread = new MyThread();        MyThread thread2 = new MyThread();   //创建新线程thread2        thread.start();        thread2.start();   //启动线程thread2     } }

修改示例3，将直接调用线程实例的run()方法。如示例4。

package shili04; /**  * 测试类  * 示例04  * @author Lihui  *  * 2018年4月10日  */ publicclass Test {     publicstaticvoid main(String[] args) {        MyThread t1 = new MyThread();        MyThread t2 = new MyThread();   //创建新线程thread2        //直接调用方法run()        t1.run();        t2.run();     } }

7.2.4  实现Runnable接口创建线程

         使用继承Thread类的方式创建线程简单明了，符合大家的习惯，但他也有一个缺店，如果定义得类已经继承了其他类，则无法再继承Thread类。

package shili05; /**  * 示例05  * @author Lihui  *  * 2018年4月10日  */ publicclass MyRunnable implements Runnable{     //实现run()方法     publicvoid run()     {        for (int i = 1; i < 100; i++) {            System.out.println(Thread.currentThread().getName() + ":" + i);        }     } }       publicclass Test {     publicstaticvoid main(String[] args) {        MyRunnable myRunnable = new MyRunnable();        Thread myThread = new Thread(myRunnable);        myThread.start();     } }

7.3  线程的状态

         任何线程一般都具有五种状态，即创建、就绪、运行、阻塞、死亡状态。

新建和就绪

程序使用new会新建一个线程，new出的对象跟普通对象一样，JVM会为其分配内存，初始化成员变量等，此时线程并没有运行，而是就是新建状态。

当线程对象调用start后，线程将进入就绪状态。JVM会为其创建函数调度栈和计数器，但此时线程依然没有运行，而是等待获取CPU执行片

下面的例子可以证明当线程对象调用start后，并不一定立即执行，

for(inti=0; i<50; i++) {
    System.out.println(Thread.currentThread().getName()+" "+i);
    if(i==20){
        SecondThread st = newSecondThread();
        newThread(st, "new thread 1").start();
    }
}

上面是在main中创建子线程，下面是运行结果，

...

main 18
main 19
main 20
main 21
main 22
newthread 10
main 23
newthread 11
main 24
newthread 12
main 25

...

从上面的运行结果可以看到，原本在main中i=20的时候新建了一个子线程，并立即调用了start()使线程进入就绪状态，但是一直等到i=22的时候，子线程才开始运行，所以子线程何时会开始执行取决于CPU执行片的分配，由JVM调度器决定。

运行和阻塞状态

当就绪状态的线程获取了CPU执行片的之后，就进入运行状态，但是在执行过程中，可能会因为以下原因使线程进入阻塞状态，

·        CPU执行片已经用完，JVM切换到其他线程执行

·        线程调用sleep()

·        线程调用了阻塞IO方法，该方法返回之前，线程会一直阻塞

·        线程试图获取被其他线程持有的同步监视器

·        线程在等待某个通知

·        程序调用了线程的suspend()将线程挂起。（容易死锁，不推荐）

线程从运行进入阻塞状态之后，接着只能继续阻塞或者再次进入就绪状态，下面情况会使线程由阻塞状态重新进入就绪状态，

·        线程调用的slee()经过了指定时间

·        线程调用的阻塞IO方法返回

·        线程成功获取同步监视器

·        线程收到其他线程发出的通知

·        被挂起(suspend)的线程又被程序调用了resume方法

下图演示了线程状态转换过程，

注意从上图可知，

线程从阻塞状态只能进入就绪状态，

通常情况下，就绪状态和运行状态的转换是不受程序控制的，而是由JVM线程调度机制控制的

yield()方法可以让运行状态的线程进入就绪状态

线程死亡

线程结束后就处于死亡状态，线程会以如下三种方式结束，

·        run()或call()正常执行完成，线程正常结束

·        线程抛出一个未捕获的Exception或Error

·        直接调用线程的stop()方法结束线程，容易死锁

注意，子线程一旦启动，其地位和主线程是一样的，所以一旦主线程结束了，子线程不会受影响，不会跟着结束

线程对象的isAlive()方法在就绪，运行，阻塞时返回true，在新建，死亡时返回false

对已经死亡的线程调用start()是无效的，会抛出异常。死亡的线程不可再次作为线程来执行。

对于新建的线程，调用两次start()方法也会抛出异常

7.4  线程的调度

         在单CPU的计算机中，一个时刻只有一个线程进行，所谓多线程的并发运行，其实是指从宏观上看，各个线程轮流获得CPU资源的使用权，分别执行各自的任务。Java虚拟机的一项任务就是负责线程的调度，线程调度是指按照特定机制多个线程分配CPU的使用权。

7.4.1  线程的优先级

1.在任意时刻，当有多个线程处于可运行状态时，运行系统总是挑选一个优先级最高的线程执行，只有当线程停止、退出或者由于某些原因不执行的时候，低优先级的线程才可能被执行

2.两个优先级相同的线程同时等待执行时，那么运行系统会以round-robin的方式选择一个线程执行（即轮询调度，以该算法所定的）（Java的优先级策略是抢占式调度！）

3.被选中的线程可因为一下原因退出，而给其他线程执行的机会：

1) 一个更高优先级的线程处于可运行状态（Runnable）

2）线程主动退出（yield），或它的run方法结束

3）在支持分时方式的系统上，分配给该线程的时间片结束

4.Java运行系统的线程调度算法是抢占式（preemptive）的，当更高优先级的线程出现并处于Runnable状态时，运行系统将选择高优先级的线程执行

5.例外地，当高优先级的线程处于阻塞状态且CPU处于空闲时，低优先级的线程也会被调度执行

 1publicclass PriorityExample{

 2     publicstaticvoid main(Strinig[] args){

 3         Thread a = new PThread("A");

 4         Thread b = new PThread("B");

 5         a.setPriority(7); //设置优先级

 6         a.setPriority(1);

 7     }

 8 }

 9

10class PThread extends Thread{

11     public PThread(String n){

12         super(n);

13     }

14

15     publicvoid run(){

16         for(int i=0; i<5000000; i++){

17             if(i%5000000 == 0){

18                 System.out.print(getName());

19             }

20         }

21     }

22 }

 

输出 AAAAAAAAABBBBBBBBB

 

 

利己线程

---

 

1.一般地，在线程中可以调用sleep方法，放弃当前线程对处理器的使用，从而使各个线程均有机会得到执行，但有时候线程可能不遵循这个规则！

1publicvoid run(){

2     for(int i=0; i<5000000; i++){

3         if(i%5000000 == 0){

4             System.out.print(getName());

5         }

6     }

7 }

 

2.for循环是一个紧密循环，一旦运行系统选择了有for循环体的线程执行，该线程就不会放弃对处理器的使用权，除非for循环自然终止或者该线程被一个有更高优先级的线程抢占，这样的线程称为利己线程

3.利己线程一般不引起问题，但有时会让其他的线程得到处理器使用权之前等待一段很长的时间

 

 

分时方式

---

 

1.为解决利己线程可能长时间占据CPU的问题，有些系统通过分时方式来限制利己线程的执行，如Windows2000或WindowsNT系统

2.在分时方式中，处理器的分配按照时间片来划分，对于那些具有相同最高优先级的多个线程，分时技术会交替地分配CPU时间片给他们执行，当时间片结束，即使该线程没有运行结束，也会让出CPU使用权

3.注释掉优先级设置后，输出变成了AAAAABBBBBAAABBB或者AABBAAAABBBBAABBA

 1 publicclass PriorityExample{

 2     publicstaticvoid main(Strinig[] args){

 3         Thread a = new PThread("A");

 4         Thread b = new PThread("B");

 5         //a.setPriority(7); //设置优先级

 6         //a.setPriority(1);

 7     }

 8 }

 9 

10 class PThread extends Thread{

11     public PThread(String n){

12         super(n);

13     }

14 

15     publicvoid run(){

16         for(int i=0; i<5000000; i++){

17             if(i%5000000 == 0){

18                 System.out.print(getName());

19             }

20         }

21     }

22 } 

 

而如果在另一个不支持分时技术的平台上运行程序，得到的输出结果可能是确定的！ AAAAAAAAABBBBBBBBB

 

4.Java运行系统不实现分时，分时是和平台相关的，而有的平台不支持分时，在编写Java多线程程序的时候，不能过分依赖分时技术来保证各个线程都有公平的执行机会！通常应编写那种可以主动放弃处理器使用权的程序，同时一个线程也可以调用yield方法主动放弃对处理器的使用权

　　注意：使用yield只能给同优先级的线程提供执行机会，如果没有同优先级的线程处于可运行状态，yield方法将被忽略！

7.4.2  线程的休眠

一、sleep()介绍

sleep() 定义在Thread.java中。
sleep() 的作用是让当前线程休眠，即当前线程会从“运行状态”进入到“休眠(阻塞)状态”。sleep()会指定休眠时间，线程休眠的时间会大于/等于该休眠时间；在线程重新被唤醒时，它会由“阻塞状态”变成“就绪状态”，从而等待cpu的调度执行。

二、sleep()示例

下面通过一个简单示例演示sleep()的用法。

package com.demo.sleep;

 

publicclass ThreadA extends Thread{

   

     public ThreadA(String name){

         super(name);

     }

    

     publicsynchronizedvoid run() {

        try {

            for(int i=0; i <10; i++){

                System.out.printf("%s:%d\n", this.getName(), i);

                // i能被4整除时，休眠100毫秒

                if (i%4 == 0)

                    Thread.sleep(100);

            }

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

    }

}

package com.demo.sleep;

 

publicclass SleepTest {

   

    publicstaticvoid main(String[] args){

        ThreadA t1 = new ThreadA("t1");

        t1.start();

    }

}

运行结果：

t1: 0

t1: 1

t1: 2

t1: 3

t1: 4

t1: 5

t1: 6

t1: 7

t1: 8

t1: 9

结果说明：
程序比较简单，在主线程main中启动线程t1。t1启动之后，当t1中的计算i能被4整除时，t1会通过Thread.sleep(100)休眠100毫秒。

三、sleep()与wait()的比较

     我们知道，wait()的作用是让当前线程由“运行状态”进入“等待(阻塞)状态”的同时，也会释放同步锁。而sleep()的作用是也是让当前线程由“运行状态”进入到“休眠(阻塞)状态”。但是，wait()会释放对象的同步锁，而sleep()则不会释放锁。

下面通过示例演示sleep()是不会释放锁的。

package com.demo.sleep;

 

publicclass ThreadB extends Thread{

    

     privatestatic Object obj = new Object();

    

     public ThreadB(String name){

         super(name);

     }

    

     publicvoid run(){

         synchronized(obj){

             try {

                 for(int i=0; i <10; i++){

                    System.out.printf("%s: %d\n", this.getName(), i);

                     // i能被4整除时，休眠100毫秒

                     if (i%4 == 0)

                         Thread.sleep(100);

                 }

             } catch (InterruptedException e) {

                 e.printStackTrace();

             }

         }

     }

}

package com.demo.sleep;

 

publicclass SleepLockTest {

   

     publicstaticvoid main(String[] args){

        

         ThreadB t1 = new ThreadB("t1");

         ThreadB t2 = new ThreadB("t2");

         t1.start();

         t2.start();

     }

}

运行结果：

t1: 0

t1: 1

t1: 2

t1: 3

t1: 4

t1: 5

t1: 6

t1: 7

t1: 8

t1: 9

t2: 0

t2: 1

t2: 2

t2: 3

t2: 4

t2: 5

t2: 6

t2: 7

t2: 8

t2: 9

结果说明：
主线程main中启动了两个线程t1和t2。t1和t2在run()会引用同一个对象的同步锁，即synchronized(obj)。在t1运行过程中，虽然它会调用Thread.sleep(100)；但是，t2是不会获取cpu执行权的。因为，t1并没有释放“obj所持有的同步锁”！
注意，若我们注释掉synchronized (obj)后再次执行该程序，t1和t2是可以相互切换的。下面是注释调synchronized(obj)之后的源码：

package com.demo.sleep;

 

publicclass ThreadB extends Thread{

    

     privatestatic Object obj = new Object();

    

     public ThreadB(String name){

         super(name);

     }

    

     publicvoid run(){

         //synchronized(obj){

             try {

                 for(int i=0; i <10; i++){

                    System.out.printf("%s: %d\n", this.getName(), i);

                     // i能被4整除时，休眠100毫秒

                     if (i%4 == 0)

                         Thread.sleep(100);

                 }

             } catch (InterruptedException e) {

                 e.printStackTrace();

             }

         //}

     }

}

再次运行SleepLockTest.java，结果如下：

t1: 0

t2: 0

t2: 1

t2: 2

t1: 1

t1: 2

t2: 3

t1: 3

t2: 4

t1: 4

t1: 5

t1: 6

t1: 7

t1: 8

t2: 5

t2: 6

t2: 7

t2: 8

t1: 9

t2: 9

7.4.3  线程的强制运行

Java终止正在运行的线程的方式有如下三种

·        1 使用退出标志，使线程正常退出，也就是run方法完成后线程终止

·        2 使用stop方法强行终止线程（已过时），但是不推荐使用这个方法

·        3 使用interrupt方法中断线程

1 使用退出标志，使线程正常退出，也就是run方法完成后线程终止

当run方法正常执行完，线程也就停止了，当有循环时，可设置一个标志变量，为真时运行，否则退出循环，主要代码如下：

publicvoidrun() {

    while(flag){

        //do something

    }

}

想要终止运行时，只需设置flag值为false即可。

2 使用stop方法强行终止线程（已过时）

使用stop()方法能立即停止线程，但是可能使一些请理性工作得不到完成。另一种情况就是对锁锁定的对象经行了“解锁”，导致数据得不到同步的处理，出现不一致的问题

3 使用interrupt方法中断线程

值得注意的是，interrupt()方法并不能真正停止线程，而是在当前线程打了一个停止的标记，可用以下方法停止线程。

publicvoidrun() {

        while (true) {

            if (this.interrupted())

                break;

            System.out.println("running");

        }

        System.out.println("退出线程");

调用interrupt()方法，this.interrupted()结果为true，退出循环，但会继续执行System.out.println(“退出线程”);然后正常退出线程。可以采用抛异常的方式终止线程，代码如下

publicvoidrun() {

    try {

        while (true) {

            if (this.interrupted()) {

                thrownew InterruptedException();

            }

            System.out.println("running");

        }

    } catch (InterruptedException e) {

        e.printStackTrace();

    }

}

7.4.4  线程的礼让

         Yield()方法定义的语法如下：

public static void yield()

Yield()方法课暂停当前线程执行，允许其他具有相同优先级的线程获得运行机会，该线程任处于就绪状态，不转为阻塞状态，此时，系统选择其他相同或更高优先级程执行，若无其他相同或更高优先级线程，则该线程继续执行。

package shili10; /**  * 示例10  * @author Lihui  *  * 2018年4月10日  */ publicclass MyThread implements Runnable{     publicvoid run()     {        for (int i = 0; i < 5; i++) {            System.out.println(Thread.currentThread().getName() + "正在运行" + i);            if (i == 3) {               System.out.println("线程礼让");               Thread.yield();            }        }     } }       publicclass ThreadYieldDemo {     publicstaticvoid main(String[] args) {        Mythread my = new Mythread();        Thread t1 = new Thread(my,"线程A");        Thread t2 = new Thread(my,"线程B");        t1.start();     } }

7.5  线程的同步

7.5.2  线程同步的实现

同步的方法：

一、同步方法

　　即有synchronized关键字修饰的方法。 由于java的每个对象都有一个内置锁，当用此关键字修饰方法时， 内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。

注：synchronized关键字也可以修饰静态方法，此时如果调用该静态方法，将会锁住整个类。

 

二、同步代码块

　　即有synchronized关键字修饰的语句块。 被该关键字修饰的语句块会自动被加上内置锁，从而实现同步

    代码如： 

synchronized(object){

}

   注：同步是一种高开销的操作，因此应该尽量减少同步的内容。通常没有必要同步整个方法，使用synchronized代码块同步关键代码即可。 

    package com.xhj.thread;

 

    /**

     * 线程同步的运用

     *

     * @author XIEHEJUN

     *

     */

    publicclassSynchronizedThread {

 

        class Bank {

            privateint account = 100;

            publicint getAccount() {

                return account;

            }

 

            /**

             * 用同步方法实现

             *

             * @param money

             */

            publicsynchronizedvoid save(int money) {

                account += money;

            }

 

            /**

             * 用同步代码块实现

             *

             * @param money

             */

            publicvoid save1(int money) {

                synchronized (this) {

                    account += money;

                }

            }

        }

class NewThread implements Runnable {

            private Bank bank;

 

            public NewThread(Bankbank) {

                this.bank = bank;

            }

 

            @Override

            publicvoid run() {

                for (int i = 0; i < 10;i++) {

                    // bank.save1(10);

                    bank.save(10);

                   System.out.println(i + "账户余额为：" +bank.getAccount());

                }

            }

 

        }

 

        /**

         * 建立线程，调用内部类

         */

        publicvoid useThread() {

            Bank bank = new Bank();

            NewThread new_thread = new NewThread(bank);

           System.out.println("线程1");

            Thread thread1 = newThread(new_thread);

            thread1.start();

           System.out.println("线程2");

            Thread thread2 = newThread(new_thread);

            thread2.start();

        }

 

        publicstaticvoid main(String[]args) {

            SynchronizedThread st = newSynchronizedThread();

            st.useThread();

        }

 

    }

 

 

        

=====================================

示例加讲解

同步是多线程中的重要概念。同步的使用可以保证在多线程运行的环境中，程序不会产生设计之外的错误结果。同步的实现方式有两种，同步方法和同步块，这两种方式都要用到synchronized关键字。

同步方法:给一个方法增加synchronized修饰符之后就可以使它成为同步方法，这个方法可以是静态方法和非静态方法，但是不能是抽象类的抽象方法，也不能是接口中的接口方法。下面代码是一个同步方法的示例：

publicsynchronizedvoid aMethod() {

    // do something

}

 

publicstaticsynchronizedvoid anotherMethod() {

    // do something

}

线程在执行同步方法时是具有排它性的。当任意一个线程进入到一个对象的任意一个同步方法时，这个对象的所有同步方法都被锁定了，在此期间，其他任何线程都不能访问这个对象的任意一个同步方法，直到这个线程执行完它所调用的同步方法并从中退出，从而导致它释放了该对象的同步锁之后。在一个对象被某个线程锁定之后，其他线程是可以访问这个对象的所有非同步方法的。

同步块：同步块是通过锁定一个指定的对象，来对同步块中包含的代码进行同步；而同步方法是对这个方法块里的代码进行同步，而这种情况下锁定的对象就是同步方法所属的主体对象自身。如果这个方法是静态同步方法呢？那么线程锁定的就不是这个类的对象了，也不是这个类自身，而是这个类对应的java.lang.Class类型的对象。同步方法和同步块之间的相互制约只限于同一个对象之间，所以静态同步方法只受它所属类的其它静态同步方法的制约，而跟这个类的实例（对象）没有关系。

如果一个对象既有同步方法，又有同步块，那么当其中任意一个同步方法或者同步块被某个线程执行时，这个对象就被锁定了，其他线程无法在此时访问这个对象的同步方法，也不能执行同步块。

synchronized 关键字用于保护共享数据。请大家注意“共享数据”，你一定要分清哪些数据是共享数据，请看下面的例子：

publicclass ThreadTest implements Runnable{

 

publicsynchronizedvoid run(){

for(int i=0;i<10;i++) {

System.out.print(" " + i);

}

}

 

publicstaticvoid main(String[] args) {

Runnable r1 = new ThreadTest(); //也可写成ThreadTest r1 = new ThreadTest();

Runnable r2 = new ThreadTest();

Thread t1 = new Thread(r1);

Thread t2 = new Thread(r2);

t1.start();

t2.start();

}}

 

在这个程序中，run()虽然被加上了synchronized 关键字，但保护的不是共享数据。因为这个程序中的t1,t2 是两个对象（r1,r2）的线程。而不同的对象的数据是不同的，r1,r2 有各自的run()方法，所以输出结果无法预知。

synchronized的目的是使同一个对象的多个线程，在某个时刻只有其中的一个线程可以访问这个对象的synchronized 数据。每个对象都有一个“锁标志”，当这个对象的一个线程访问这个对象的某个synchronized 数据时，这个对象的所有被synchronized 修饰的数据将被上锁（因为“锁标志”被当前线程拿走了），只有当前线程访问完它要访问的synchronized 数据时，当前线程才会释放“锁标志”，这样同一个对象的其它线程才有机会访问synchronized 数据。

示例3：

publicclass ThreadTest implements Runnable{

 

publicsynchronizedvoid run(){

for(int i=0;i<10;i++){

System.out.print(" " + i);

}

}

 

publicstaticvoid main(String[] args){

Runnable r = new ThreadTest();

Thread t1 = new Thread(r);

Thread t2 = new Thread(r);

t1.start();

t2.start();

}}

 

如果你运行1000 次这个程序，它的输出结果也一定每次都是：0 1 2 3 4 5 67 8 9 0 1 2 3 4 5 6 7 8 9。因为这里的synchronized 保护的是共享数据。t1,t2 是同一个对象（r）的两个线程，当其中的一个线程（例如：t1）开始执行run()方法时，由于run()受synchronized保护，所以同一个对象的其他线程（t2）无法访问synchronized 方法（run 方法）。只有当t1执行完后t2 才有机会执行。

示例4：

publicclass ThreadTest implements Runnable{

 

publicvoid run(){

 

    synchronized(this){

    for(int i=0;i<10;i++){

        System.out.print("" + i);

    }

}

}

 

publicstaticvoid main(String[] args){

    Runnable r = new ThreadTest();

    Thread t1 = new Thread(r);

    Thread t2 = new Thread(r);

    t1.start();

    t2.start();

}

}   

 

这个程序与示例3 的运行结果一样。在可能的情况下，应该把保护范围缩到最小，可以用示例4 的形式，this 代表“这个对象”。没有必要把整个run()保护起来，run()中的代码只有一个for循环，所以只要保护for 循环就可以了。

示例5：

publicclass ThreadTest implements Runnable{

 

publicvoid run(){

for(int k=0;k<5;k++){

System.out.println(Thread.currentThread().getName()+" : for loop : " + k);

}

 

synchronized(this){

for(int k=0;k<5;k++) {

System.out.println(Thread.currentThread().getName()+" : synchronized for loop : " + k);

}} }

 

publicstaticvoid main(String[] args){

Runnable r = new ThreadTest();

Thread t1 = newThread(r,"t1_name");

Thread t2 = newThread(r,"t2_name");

t1.start();

t2.start();

} }

 

运行结果：

t1_name : for loop: 0

t1_name : for loop: 1

t1_name : for loop: 2

t2_name : for loop: 0

t1_name : for loop: 3

t2_name : for loop: 1

t1_name : for loop: 4

t2_name : for loop: 2

t1_name :synchronized for loop : 0

t2_name : for loop: 3

t1_name :synchronized for loop : 1

t2_name : for loop: 4

t1_name :synchronized for loop : 2

t1_name : synchronizedfor loop : 3

t1_name :synchronized for loop : 4

t2_name :synchronized for loop : 0

t2_name :synchronized for loop : 1

t2_name :synchronized for loop : 2

t2_name :synchronized for loop : 3

t2_name :synchronized for loop : 4

第一个for 循环没有受synchronized 保护。对于第一个for 循环，t1,t2 可以同时访问。运行结果表明t1 执行到了k=2 时，t2 开始执行了。t1 首先执行完了第一个for 循环，此时t2还没有执行完第一个for 循环（t2 刚执行到k=2）。t1 开始执行第二个for 循环，当t1的第二个for 循环执行到k=1 时，t2 的第一个for 循环执行完了。t2 想开始执行第二个for 循环，但由于t1 首先执行了第二个for 循环，这个对象的锁标志自然在t1 手中（synchronized 方法的执行权也就落到了t1 手中），在t1 没执行完第二个for 循环的时候，它是不会释放锁标志的。所以t2 必须等到t1 执行完第二个for 循环后，它才可以执行第二个for 循环。

=====================================

三、wait与notify

wait():使一个线程处于等待状态，并且释放所持有的对象的lock。

sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。
notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。
Allnotity():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。

详细见：wait、notify、notifyAll的使用方法

四、使用特殊域变量(volatile)实现线程同步

    a.volatile关键字为域变量的访问提供了一种免锁机制

    b.使用volatile修饰域相当于告诉虚拟机该域可能会被其他线程更新

    c.因此每次使用该域就要重新计算，而不是使用寄存器中的值 

    d.volatile不会提供任何原子操作，它也不能用来修饰final类型的变量 

    

    例如： 

        在上面的例子当中，只需在account前面加上volatile修饰，即可实现线程同步。 

    

    代码实例： 

 

        //只给出要修改的代码，其余代码与上同

        class Bank {

            //需要同步的变量加上volatile

            privatevolatileint account = 100;

 

            publicint getAccount() {

                return account;

            }

            //这里不再需要synchronized

            publicvoid save(int money) {

                account += money;

            }

        ｝

    注：多线程中的非同步问题主要出现在对域的读写上，如果让域自身避免这个问题，则就不需要修改操作该域的方法。 

    用final域，有锁保护的域和volatile域可以避免非同步的问题。 

五、使用重入锁实现线程同步

    在JavaSE5.0中新增了一个java.util.concurrent包来支持同步。 

    ReentrantLock类是可重入、互斥、实现了Lock接口的锁，它与使用synchronized方法和快具有相同的基本行为和语义，并且扩展了其能力。

 ReenreantLock类的常用方法有：

ReentrantLock() : 创建一个ReentrantLock实例

lock() : 获得锁

unlock() : 释放锁

注：ReentrantLock()还有一个可以创建公平锁的构造方法，但由于能大幅度降低程序运行效率，不推荐使用 

        

    例如： 

        在上面例子的基础上，改写后的代码为: 

       //只给出要修改的代码，其余代码与上同

        class Bank {

           

            privateint account = 100;

            //需要声明这个锁

            private Lock lock = new ReentrantLock();

            publicint getAccount() {

                return account;

            }

            //这里不再需要synchronized

            publicvoid save(int money) {

                lock.lock();

                try{

                    account +=money;

                }finally{

                    lock.unlock();

                }

               

            }

        ｝

   注：关于Lock对象和synchronized关键字的选择： 

        a.最好两个都不用，使用一种java.util.concurrent包提供的机制，能够帮助用户处理所有与锁相关的代码。 

        b.如果synchronized关键字能满足用户的需求，就用synchronized，因为它能简化代码 

        c.如果需要更高级的功能，就用ReentrantLock类，此时要注意及时释放锁，否则会出现死锁，通常在finally代码释放锁 

 

六、使用局部变量实现线程同步

    如果使用ThreadLocal管理变量，则每一个使用该变量的线程都获得该变量的副本，副本之间相互独立，这样每一个线程都可以随意修改自己的变量副本，而不会对其他线程产生影响。

     ThreadLocal 类的常用方法

ThreadLocal() : 创建一个线程本地变量

get() : 返回此线程局部变量的当前线程副本中的值

initialValue() : 返回此线程局部变量的当前线程的"初始值"

set(T value) : 将此线程局部变量的当前线程副本中的值设置为value

    例如： 

        在上面例子基础上，修改后的代码为： 

        //只改Bank类，其余代码与上同

        publicclass Bank{

            //使用ThreadLocal类管理共享变量account

            privatestaticThreadLocal<Integer> account = newThreadLocal<Integer>(){

                @Override

                protected IntegerinitialValue(){

                    return 100;

                }

            };

            publicvoid save(int money){

               account.set(account.get()+money);

            }

            publicint getAccount(){

                return account.get();

            }

        }

    注：ThreadLocal与同步机制 

        a.ThreadLocal与同步机制都是为了解决多线程中相同变量的访问冲突问题。 

        b.前者采用以"空间换时间"的方法，后者采用以"时间换空间"的方式

 

七、使用阻塞队列实现线程同步

前面5种同步方式都是在底层实现的线程同步，但是我们在实际开发当中，应当尽量远离底层结构。使用javaSE5.0版本中新增的java.util.concurrent包将有助于简化开发。本小节主要是使用LinkedBlockingQueue<E>来实现线程的同步 LinkedBlockingQueue<E>是一个基于已连接节点的，范围任意的blocking queue。 队列是先进先出的顺序（FIFO），关于队列以后会详细讲解~LinkedBlockingQueue 类常用方法 LinkedBlockingQueue(): 创建一个容量为Integer.MAX_VALUE的LinkedBlockingQueueput(E e) : 在队尾添加一个元素，如果队列满则阻塞 size() : 返回队列中的元素个数 take() : 移除并返回队头元素，如果队列空则阻塞代码实例： 实现商家生产商品和买卖商品的同步

 

注：BlockingQueue<E>定义了阻塞队列的常用方法，尤其是三种添加元素的方法，我们要多加注意，当队列满时：

　　add()方法会抛出异常

　　offer()方法返回false

　　put()方法会阻塞

 

 

7.使用原子变量实现线程同步

 

需要使用线程同步的根本原因在于对普通变量的操作不是原子的。

那么什么是原子操作呢？原子操作就是指将读取变量值、修改变量值、保存变量值看成一个整体来操作即-这几种行为要么同时完成，要么都不完成。在java的util.concurrent.atomic包中提供了创建了原子类型变量的工具类，使用该类可以简化线程同步。其中AtomicInteger 表可以用原子方式更新int的值，可用在应用程序中(如以原子方式增加的计数器)，但不能用于替换Integer；可扩展Number，允许那些处理机遇数字类的工具和实用工具进行统一访问。

AtomicInteger类常用方法：

AtomicInteger(intinitialValue) : 创建具有给定初始值的新的

AtomicIntegeraddAddGet(intdalta) : 以原子方式将给定值与当前值相加

get() : 获取当前值

代码实例：

只改Bank类，其余代码与上面第一个例子同

class Bank {

    private AtomicIntegeraccount = new AtomicInteger(100);

    public AtomicIntegergetAccount() {

        return account;

    }

    publicvoid save(int money) {

        account.addAndGet(money);

    }

}

7.5.3  线程安全的类型

在使用多线程时，就不得不考虑线程安全问题了。对于int，long 这种基本类型，是不具有线程安全的，所以就特别期望能有一种线程安全的基本类型，类似使用redis 那样，在多线程中也丝毫不用考虑多线程问题。最近，突然发现了原来java 也自带了线程安全的基本类型，包括： AtomicInteger,AtomicLong, AtomicBoolean, AtomicIntegerArray,AtomicLongArray; 等，感觉实在是太棒了。

 

1. 测试代码

[java]viewplaincopy

1.  package org.zgf.test;  

2.    

3.  import java.util.concurrent.atomic.AtomicInteger;  

4.    

5.  public class TestAtomic {  

6.    

7.      public static void main(String[] args) {  

8.          AtomicInteger atomicInteger = new AtomicInteger(1);  

9.            

10.          int number = 0;  

11.            

12.          //getAndAdd: 先获取值，再自增10，返回值为自增前的值  

13.          number = atomicInteger.getAndAdd(10);  

14.          System.out.println("getAndAdd       --> number:" + number + ", atomicInteger: " + atomicInteger);  

15.            

16.          //getAndDecrement: 先获得值，再自减1，返回值为自减前的  

17.          number = atomicInteger.getAndDecrement();  

18.          System.out.println("getAndDecrement --> number:" + number + ", atomicInteger: " + atomicInteger);  

19.            

20.          //getAndIncrement: 先获得值，再自增1，返回值为自增前的值  

21.          number = atomicInteger.getAndIncrement();  

22.          System.out.println("getAndIncrement --> number:" + number + ", atomicInteger: " + atomicInteger);  

23.            

24.          //getAndSet: 先获得值,再赋值，返回值为赋值前的值  

25.          number = atomicInteger.getAndSet(10);  

26.          System.out.println("getAndSet       --> number:" + number + ", atomicInteger: " + atomicInteger);  

27.            

28.          //addAndGet: 先自增，再返回值，返回值为自增后的值  

29.          number = atomicInteger.addAndGet(10);  

30.          System.out.println("addAndGet       --> number:" + number + ", atomicInteger: " + atomicInteger);  

31.            

32.          //decrementAndGet: 先自减1，再获取返回值，返回值为自减后的值  

33.          number = atomicInteger.decrementAndGet();  

34.          System.out.println("decrementAndGet --> number:" + number + ", atomicInteger: " + atomicInteger);  

35.            

36.          //incrementAndGet: 先自增1，再返回值，返回值为自增后的值  

37.          number = atomicInteger.incrementAndGet();  

38.          System.out.println("incrementAndGet --> number:" + number + ", atomicInteger: " + atomicInteger);  

39.            

40.          //compareAndSet: 如果当前值为20，则设置为100  

41.          boolean isSuccess = atomicInteger.compareAndSet(20, 100);  

42.          System.out.println("compareAndSet: " + isSuccess);  

43.            

44.      }  

45.  }  

2. 输出结果：

[html]viewplaincopy

1.  getAndAdd       --> number:1, atomicInteger: 11  

2.  getAndDecrement --> number:11, atomicInteger: 10  

3.  getAndIncrement --> number:10, atomicInteger: 11  

4.  getAndSet       --> number:11, atomicInteger: 10  

5.  addAndGet       --> number:20, atomicInteger: 20  

6.  decrementAndGet --> number:19, atomicInteger: 19  

7.  incrementAndGet --> number:20, atomicInteger: 20  

8.  compareAndSet: true  

 

2. 输出结果：

[html]viewplaincopy

1.  getAndAdd       --> number:1, atomicInteger: 11  

2.  getAndDecrement --> number:11, atomicInteger: 10  

3.  getAndIncrement --> number:10, atomicInteger: 11  

4.  getAndSet       --> number:11, atomicInteger: 10  

5.  addAndGet       --> number:20, atomicInteger: 20  

6.  decrementAndGet --> number:19, atomicInteger: 19  

7.  incrementAndGet --> number:20, atomicInteger: 20  

8.  compareAndSet: true