资源竞争 (线程互斥)
1、什么是资源竞争
有这样一种资源，在某一时刻只能被一个线程所使用：比如打印机、某个文件等等，如果多个线程不加控制的同时使用这类资源，必然会导至错误。
下面的例子模拟了一个打印机，多个线程不加控制的同时使用这个打印机：
public class Printer
{
public void print(int printer, String content)
{
System.out.println("Start working for [" +printer+"]");
Thread.yield();
System.out.println("＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝");
Thread.yield();
System.out.println(content);
Thread.yield();
System.out.println("＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝");
Thread.yield();
System.out.println("Work complete for [" +printer+"]\n");
}
public static void main(String[] args)
{
Printer p = new Printer();
for (int i=0; i<3; i++)
new Thread(new MyThread(p)).start();
}
}
class MyThread implements Runnable
{
private static int counter = 0;
private final int id = counter++;
private Printer printer;
public MyThread(Printer printer)
{
this.printer = printer;
}
@Override
public void run()
{
printer.print(id, "Content of " + id);
}
}
输出结果(sample)
Start working for [0]
Start working for [1]
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
Start working for [2]
Content of 0
Content of 1
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
Content of 2
Work complete for [0]
Work complete for [1]
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
Work complete for [2]
从结果可以看到，打印机的输出完全乱套了，各个线程想要打印的内容全部参杂在一起了。
2、解决资源竞争问题
原则上要解决这类问题并不难，只需要一个锁的机制。任何线程在使用打印机前必须先对打印机上锁；在使用完打印机后释放锁；如果线程尝试对打印机上锁时别的线程已经上了锁，则该线程必须等待别的线程先释放锁。
Java中，解决上述资源共享类的问题是通过关键字synchronized实现的。java中的对象都有一个‘锁’，这样，任何一个线程尝试访问对象的synchronized方法时，必须要先获得对象的'锁'，否则必须等待。
一个对象可能会有多个synchronized方法，比如synchronized a()方法和synchronized b()方法。当一个线程获得了对象的锁，进行a()方法、或b()方法了，那么在线程释放该对象的锁之前，别的线程是不能访问该对象的其它synchronized方法的。
下面例子是之前的例子的改良版本，只需要简单的把Printer对象的print方法定义成synchronized的就可以达到我们的要求了：
public class Printer
{
public synchronized void print(int printer, String content)
{
System.out.println("Start working for [" +printer+"]");
Thread.yield();
System.out.println("＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝");
Thread.yield();
System.out.println(content);
Thread.yield();
System.out.println("＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝");
Thread.yield();
System.out.println("Work complete for [" +printer+"]\n");
}
public static void main(String[] args)
{
Printer p = new Printer();
for (int i=0; i<3; i++)
new Thread(new MyThread(p)).start();
}
}
class MyThread implements Runnable
{
private static int counter = 0;
private final int id = counter++;
private Printer printer;
public MyThread(Printer printer)
{
this.printer = printer;
}
@Override
public void run()
{
printer.print(id, "Content of " + id);
}
}
输出结果
Start working for [0]
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
Content of 0
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
Work complete for [0]
Start working for [2]
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
Content of 2
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
Work complete for [2]
Start working for [1]
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
Content of 1
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
Work complete for [1]
从结果的输出可以看出来，被模拟的打印机资源在某一时刻，仅被一个线程所使用。
3、临界区
有些时候，你可能不需要隔离整个方法，而只需要隔离方法中的部分代码，这部分被隔离的代码就叫做临界区。临界区中的代码在某一时刻，只能被一个线程访问。
下面的例子，是用临界区的方式实现了前面的例子：
public class Printer
{
public void print(int printer, String content)
{
synchronized(this)
{
System.out.println("Start working for [" +printer+"]");
Thread.yield();
System.out.println("＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝");
Thread.yield();
System.out.println(content);
Thread.yield();
System.out.println("＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝");
Thread.yield();
System.out.println("Work complete for [" +printer+"]\n");
}
}
public static void main(String[] args)
{
Printer p = new Printer();
for (int i=0; i<3; i++)
new Thread(new MyThread(p)).start();
}
}
class MyThread implements Runnable
{
private static int counter = 0;
private final int id = counter++;
private Printer printer;
public MyThread(Printer printer)
{
this.printer = printer;
}
@Override
public void run()
{
printer.print(id, "Content of " + id);
}
}
可以看到，在Java中临界区也是通过synchronized关键字实现的。在synchronized关键字后面，要传一个对象参数，任何线程要进入临界区时必须先要获得该对象的锁，退出临界区时要释放该对象的锁，这样别的线程才有机会进入临界区。
从上面两个例子可以看出，临界区和synchronized方法，其原理都是一样的，都是通过在对象上加锁来实现的，只不过临界区来得更加灵活，因为它不光可以对this对象加锁，也可以对任何别的对象加锁。
4、Lock
Java1.5提供了一个显示加锁的机制，比起synchronized方式来说，显示加锁的方法可能让代码看上去更加复杂，但是也带来了更好的灵活性。
下面的例子，用Lock的机制实现了前面的例子：
public class Printer
{
private Lock lock = new ReentrantLock();
public void print(int printer, String content)
{
lock.lock();
try
{
System.out.println("Start working for [" +printer+"]");
Thread.yield();
System.out.println("＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝");
Thread.yield();
System.out.println(content);
Thread.yield();
System.out.println("＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝");
Thread.yield();
System.out.println("Work complete for [" +printer+"]\n");
}
finally
{
lock.unlock();
}
}
public static void main(String[] args)
{
Printer p = new Printer();
for (int i=0; i<3; i++)
new Thread(new MyThread(p)).start();
}
}
class MyThread implements Runnable
{
private static int counter = 0;
private final int id = counter++;
private Printer printer;
public MyThread(Printer printer)
{
this.printer = printer;
}
@Override
public void run()
{
printer.print(id, "Content of " + id);
}
}
使用Lock的时候，必须要注意两点：
- 锁的释放必须放在finally块里面，以保证锁被正确的释放；
- 如果被隔间的方法或临界间需要返回一个值，那么return语句应该放在try块中，从而不至于使unlock发生得过早而导至错误的发生。
使用显示的Lock机制，可以让程序更加的灵活。比如上面的例子中，如果尝试使用打印机的时候，打印机正被别的线程所使用，那么早取消本次打印。要实现这样的功能，使用synchronized可能不太容易实现，但是使用Lock机制的话，就非常简单了：
public class Printer
{
private Lock lock = new ReentrantLock();
public void print(int printer, String content)
{
boolean isLocked = lock.tryLock();
if (!isLocked)
return;
try
{
System.out.println("Start working for [" +printer+"]");
Thread.yield();
System.out.println("＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝");
Thread.yield();
System.out.println(content);
Thread.yield();
System.out.println("＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝");
Thread.yield();
System.out.println("Work complete for [" +printer+"]\n");
}
finally
{
if(isLocked)
lock.unlock();
}
}
public static void main(String[] args)
{
Printer p = new Printer();
for (int i=0; i<3; i++)
new Thread(new MyThread(p)).start();
}
}
class MyThread implements Runnable
{
private static int counter = 0;
private final int id = counter++;
private Printer printer;
public MyThread(Printer printer)
{
this.printer = printer;
}
@Override
public void run()
{
printer.print(id, "Content of " + id);
}
}
Lock.tryLock()方法尝试对lock对象加锁并返回一个boolean值，如果成功了，返回true，表明当前没有别的线程在使用打印机，那么当前线程将获得lock对象的锁，并继续打印；如果失败了，返回false，表明别的线程正在使用打印机，当前线程将简单的返回，而不是等待别的线程释放锁。
分享到：
相关推荐
Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式...
### Java多线程操作数据库：深入解析与应用 在当今高度并发的应用环境中，Java多线程技术被广泛应用于处理数据库操作，以提升系统的响应速度和处理能力。本文将基于一个具体的Java多线程操作数据库的应用程序，深入...
Java多线程读大文件 java多线程写文件：多线程往队列中写入数据
java多线程PPT 多线程基本概念 创建线程的方式 线程的挂起与唤醒 多线程问题
Java多线程是Java编程语言中一个非常重要的概念，它允许开发者在一个程序中创建多个执行线程并行运行，以提高程序的执行效率和响应速度。在Java中，线程的生命周期包含五个基本状态，分别是新建状态（New）、就绪...
Java多线程是Java编程中的重要概念，尤其在如今的多核处理器环境下，理解并熟练掌握多线程技术对于提高程序性能和响应速度至关重要。本资料详细讲解了Java多线程的原理，并提供了丰富的实战代码，非常适合Java初学者...
Java多线程是Java编程中的重要概念，它允许程序同时执行多个任务，极大地提升了程序的效率和性能。在Java中，实现多线程有两种主要方式：通过实现Runnable接口或者继承Thread类。本案例将深入探讨Java多线程中的关键...
Java多线程是Java编程中的一个重要概念，它允许程序同时执行多个任务，提高了程序的效率和响应速度。在Java中，实现多线程有两种主要方式：继承Thread类和实现Runnable接口。 1. 继承Thread类： 当我们创建一个新...
#### 二、Java多线程分页查询原理及实现 ##### 1. 分页查询基础概念 分页查询是指在查询数据时，将数据分成多个页面展示，而不是一次性返回所有数据。这种方式能够有效地减少单次查询的数据量，从而提高查询速度和...
在Java编程中，多线程处理是提升程序性能和效率的重要手段，特别是在处理大量数据库数据时。本主题将深入探讨如何使用Java的并发包（java.util.concurrent）来实现多线程对数据库数据的批量处理，包括增、删、改等...
《汪文君JAVA多线程编程实战》是一本专注于Java多线程编程的实战教程，由知名讲师汪文君倾力打造。这本书旨在帮助Java开发者深入理解和熟练掌握多线程编程技术，提升软件开发的效率和质量。在Java平台中，多线程是...
综上所述，"java多线程查询数据库"是一个涉及多线程技术、线程池管理、并发控制、分页查询等多个方面的复杂问题。通过理解和掌握这些知识点，我们可以有效地提高数据库操作的效率和系统的响应速度。
多线程启动.java多线程启动.java多线程启动.java多线程启动.java
在本文中，我们将深入浅出Java多线程编程的世界，探索多线程编程的基本概念、多线程编程的优点、多线程编程的缺点、多线程编程的应用场景、多线程编程的实现方法等内容。 一、多线程编程的基本概念 多线程编程是指...
在Java编程中，多线程并发是提升程序执行效率、充分利用多核处理器资源的重要手段。本文将基于"java 多线程并发实例"这个主题，深入探讨Java中的多线程并发概念及其应用。 首先，我们要了解Java中的线程。线程是...
《JAVA多线程教学演示系统》是一篇深入探讨JAVA多线程编程的论文，它针对教育领域中的教学需求，提供了一种生动、直观的演示方式，帮助学生更好地理解和掌握多线程技术。这篇论文的核心内容可能包括以下几个方面： ...
JAVA多线程练习题答案详解 在本文中，我们将对 JAVA 多线程练习题的答案进行详细的解释和分析。这些题目涵盖了 JAVA 多线程编程的基本概念和技术，包括线程的生命周期、线程同步、线程状态、线程优先级、线程安全等...
### JAVA中的单线程与多线程概念解析 #### 单线程的理解 在Java编程环境中，单线程指的是程序执行过程中只有一个线程在运行。这意味着任何时刻只能执行一个任务，上一个任务完成后才会进行下一个任务。单线程模型...
这份“JAVA多线程编程技术PDF”是学习和掌握这一领域的经典资料，涵盖了多线程的全部知识点。 首先，多线程的核心概念包括线程的创建与启动。在Java中，可以通过实现Runnable接口或继承Thread类来创建线程。创建后...
本项目以"java多线程实现大批量数据导入源码"为题，旨在通过多线程策略将大量数据切分，并进行并行处理，以提高数据处理速度。 首先，我们需要理解Java中的线程机制。Java通过`Thread`类来创建和管理线程。每个线程...