一步一步剖析java多线程（待续二）

原创 于 2012-12-03 22:51:54 发布 · 536 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文深入探讨Java多线程中的核心概念，包括线程同步、生产者-消费者模型及死锁问题。通过具体实例展示了如何使用synchronized关键字实现线程同步，避免数据竞争和死锁现象。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

线程的同步-同步方法
线程的同步是保证多线程安全访问竞争资源的一种手段。线程的同步是Java多线程编程的难点，往往开发者搞不清楚什么是竞争资源、什么时候需要考虑同步，怎么同步等等问题，当然，这些问题没有很明确的答案，但有些原则问题需要考虑，是否有竞争资源被同时改动的问题？在本文之前，请参阅一步一步剖析java多线程（待续一），本文是在此基础上所写的。对于同步，在具体的Java代码中需要完成一下两个操作：
把竞争访问的资源标识为private；
同步哪些修改变量的代码，使用synchronized关键字同步方法或代码。
当然这不是唯一控制并发安全的途径。
 synchronized关键字使用说明
synchronized只能标记非抽象的方法，不能标识成员变量。
 为了演示同步方法的使用，构建了一个信用卡账户，起初信用额为100w，然后模拟透支、存款等多个操作。显然银行账户User对象是个竞争资源，而多个并发操作的是账户方法oper(int x)，当然应该在此方法上加上同步，并将账户的余额设为私有变量，禁止直接访问。
  
/** 
* Java线程：线程的同步 
* 
* @author TheDream 2012年12月3日 
*/ 
public class Test { 
        public static void 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; 
        private int y = 0; 

        MyThread(String name, User u, int y) { 
                super(name); 
                this.u = u; 
                this.y = y; 
        } 

        public void run() { 
                u.oper(y); 
        } 
} 

class User { 
        private String code; 
        private int cash; 

        User(String code, int cash) { 
                this.code = code; 
                this.cash = cash; 
        } 

        public String getCode() { 
                return code; 
        } 

        public void setCode(String code) { 
                this.code = code; 
        } 

        /** 
         * 业务方法 
         * @param x 添加x万元 
         */ 
        public synchronized void 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
反面教材，不同步的情况，也就是去掉oper(int x)方法的synchronized修饰符，然后运行程序，结果如下： 
线程A运行结束，增加“20”，当前用户账户余额为：61 
线程D运行结束，增加“-30”，当前用户账户余额为：63 
线程B运行结束，增加“-60”，当前用户账户余额为：3 
线程F运行结束，增加“21”，当前用户账户余额为：61 
线程E运行结束，增加“32”，当前用户账户余额为：93 
线程C运行结束，增加“-80”，当前用户账户余额为：61 

Process finished with exit code 0
很显然，上面的结果是错误的，导致错误的原因是多个线程并发访问了竞争资源u，并对u的属性做了改动。可见同步的重要性。
注意：
通过前文可知，线程退出同步方法时将释放掉方法所属对象的锁，但还应该注意的是，同步方法中还可以使用特定的方法对线程进行调度。这些方法来自于java.lang.Object类。
 
void notify()    
                    唤醒在此对象监视器上等待的单个线程。    
void notifyAll()    
                    唤醒在此对象监视器上等待的所有线程。    
void wait()    
                    导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法。    
void wait( long timeout)    
                    导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量。    
void wait( long timeout,  int nanos)    
                    导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者其他某个线程中断当前线程，或者已超过某个实际时间量。
 结合以上方法，处理多线程同步与互斥问题非常重要，著名的生产者-消费者例子就是一个经典的例子，任何语言多线程必学的例子。
线程的同步-同步块
 对于同步，除了同步方法外，还可以使用同步代码块，有时候同步代码块会带来比同步方法更好的效果。追其同步的根本的目的，是控制竞争资源的正确的访问，因此只要在访问竞争资源的时候保证同一时刻只能一个线程访问即可，因此Java引入了同步代码快的策略，以提高性能。在上个例子的基础上，对oper方法做了改动，由同步方法改为同步代码块模式，程序的执行逻辑并没有问题。
  
/** 
* Java线程：线程的同步-同步代码块 
* 
* @author  TheDream 2012年12月3日 
*/ 
public class Test { 
        public static void 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; 
        private int y = 0; 
        MyThread(String name, User u, int y) { 
                super(name); 
                this.u = u; 
                this.y = y; 
        } 
        public void run() { 
                u.oper(y); 
        } 
} 


class User { 
        private String code; 
        private int cash; 
        User(String code, int cash) { 
                this.code = code; 
                this.cash = cash; 
        } 
        public String getCode() { 
                return code; 
        } 
        public void setCode(String code) { 
                this.code = code; 
        } 
        /** 
         * 业务方法 
         * 
         * @param x 添加x万元 
         */ 
        public void 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资源也没有意义，因为你占用着锁，其他互斥线程还是无法访问同步程序块。当然与同步程序块无关的线程可以获得更多的执行时间。
并发协作-生产者消费者模型 
对于多线程程序来说，不管任何编程语言，生产者和消费者模型都是最经典的。就像学习每一门编程语言一样，Hello World！都是最经典的例子。
实际上，准确说应该是“生产者-消费者-仓储”模型，离开了仓储，生产者消费者模型就显得没有说服力了。
对于此模型，应该明确一下几点：
1、生产者仅仅在仓储未满时候生产，仓满则停止生产。
2、消费者仅仅在仓储有产品时候才能消费，仓空则等待。
3、当消费者发现仓储没产品可消费时候会通知生产者生产。
4、生产者在生产出可消费产品时候，应该通知等待的消费者去消费。
 
此模型将要结合java.lang.Object的wait与notify、notifyAll方法来实现以上的需求。这是非常重要的。
  
/** 
* Java线程：并发协作-生产者消费者模型 
* 
* @author   TheDream 2012年12月3日 
*/ 
public class Test { 
        public static void 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 { 
        public static final int max_size = 100; //最大库存量 
        public int curnum;     //当前库存量 
        Godown() { 
        } 
       Godown(int curnum) { 
                this.curnum = curnum; 
        } 
        /** 
         * 生产指定数量的产品 
         * 
         * @param neednum 
         */ 
        public synchronized void 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 
         */ 
        public synchronized void 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 { 
        private int neednum;                //生产产品的数量 
        private Godown godown;            //仓库 


        Producer(int neednum, Godown godown) { 
                this.neednum = neednum; 
                this.godown = godown; 
        } 
        public void run() { 
                //生产指定数量的产品 
                godown.produce(neednum); 
        } 
} 
/** 
* 消费者 
*/ 
class Consumer extends Thread { 
        private int neednum;                //生产产品的数量 
        private Godown godown;            //仓库 
        Consumer(int neednum, Godown godown) { 
                this.neednum = neednum; 
                this.godown = godown; 
        } 
        public void 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() 方法，起到的是一个通知作用，不释放锁，也不获取锁。只是告诉该对象上等待的线程“可以竞争执行了，都醒来去执行吧”。
本例仅仅是生产者消费者模型中最简单的一种表示，本例中，如果消费者消费的仓储量达不到满足，而又没有生产者，则程序会一直处于等待状态，这当然是不对的。实际上可以将此例进行修改，修改为，根据消费驱动生产，同时生产兼顾仓库，如果仓不满就生产，并对每次最大消费量做个限制，这样就不存在此问题了，当然这样的例子更复杂，更难以说明这样一个简单模型。笔者喜欢简单的例子。
并发协作-死锁
 线程发生死锁可能性很小，即使看似可能发生死锁的代码，在运行时发生死锁的可能性也是小之又小。
 发生死锁的原因一般是两个对象的锁相互等待造成的。
 在一步一步剖析java多线程（待续一）一文中，简述死锁的概念与简单例子，但是所给的例子是不完整的，这里给出一个完整的例子。
  
/** 
* Java线程：并发协作-死锁 
* 
* @author  TheDream 2012年12月3日  
*/ 
public class Test { 
        public static void 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; 
        private int a, b; 
        MyThread(DeadlockRisk dead, int a, int b) { 
                this.dead = dead; 
                this.a = a; 
                this.b = b; 
        } 
        @Override 
        public void run() { 
                dead.read(); 
                dead.write(a, b); 
        } 
} 
class DeadlockRisk { 
        private static class Resource { 
                public int value; 
        } 
        private Resource resourceA = new Resource(); 
        private Resource resourceB = new Resource(); 
        public int 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; 
                        } 
                } 
        } 
        public void 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; 
                        } 
                } 
        } 
}
volatile关键字
 Java™ 语言包含两种内在的同步机制：同步块（或方法）和 volatile 变量。这两种机制的提出都是为了实现代码线程的安全性。其中 Volatile 变量的同步性较差（但有时它更简单并且开销更低），而且其使用也更容易出错。
 谈及到volatile关键字，不得不提的一篇文章是：《Java 理论与实践: 正确使用 Volatile 变量》，这篇文章对volatile关键字的用法做了相当精辟的阐述。之所以要单独提出volatile这个不常用的关键字原因是这个关键字在高性能的多线程程序中也有很重要的用途，只是这个关键字用不好会出很多问题。
 首先考虑一个问题，为什么变量需要volatile来修饰呢？
要搞清楚这个问题，首先应该明白计算机内部都做什么了。比如做了一个i++操作，计算机内部做了三次处理：读取－修改－写入。
同样，对于一个long型数据，做了个赋值操作，在32系统下需要经过两步才能完成，先修改低32位，然后修改高32位。
 假想一下，当将以上的操作放到一个多线程环境下操作时候，有可能出现的问题，是这些步骤执行了一部分，而另外一个线程就已经引用了变量值，这样就导致了读取脏数据的问题。通过这个设想，就不难理解volatile关键字了。volatile可以用在任何变量前面，但不能用于final变量前面，因为final型的变量是禁止修改的。也不存在线程安全的问题。
更多的内容，请参看：：《Java 理论与实践: 正确使用 Volatile 变量》一文，写得很好。

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值