- 浏览: 606597 次
- 性别:
- 来自: 西安
文章分类
- 全部博客 (365)
- Java 基础知识(笔试面试有用) (35)
- SQL 相关 (11)
- Oracle笔试 (1)
- Java 笔试面试 (11)
- LINUX (12)
- ExtJS (21)
- Javascript (17)
- WebGIS (2)
- 软件工程 (3)
- 数据库 (17)
- 项目管理 (63)
- 工作流 (2)
- 计算机网络 (3)
- ZigBee技术及应用 (24)
- 单片机(AVR Studio) (7)
- 项目人力资源管理 (3)
- 项目管理高级知识 (4)
- JAVA技术 (12)
- 项目管理中的概念 (3)
- SQL SERVER (1)
- C++ (1)
- C/C++编程经验 (12)
- C和C++面试笔试题 (12)
- 其他IT技术笔试面试 (6)
- 名企笔试面试集锦 (16)
- 非技术 (10)
- C#相关 (1)
- Matlab相关 (2)
- 计算机专业课相关 (2)
- Web Service (1)
- Excel 使用 (1)
- PhotoShop相关 (4)
- ASP 相关 (2)
- android (1)
- Java WEB 相关 (1)
- web 安全相关 (7)
- 网络安全 (1)
- IBatis (1)
- web 开发技巧 (2)
- css 相关 (1)
- Ruby相关 (2)
- 生活 (3)
- 操作系统安全相关 (6)
- 操作系统相关 (1)
- PHP相关 (3)
- 开发经验 (12)
- Redis (1)
最新评论
实现同步的方式
同步是多线程中的重要概念。同步的使用可以保证在多线程运行的环境中,程序不会产生设计之外的错误结果。同步的实现方式有两种,同步方法和同步块,这两种方式都要用到synchronized关键字。
给一个方法增加synchronized修饰符之后就可以使它成为同步方法,这个方法可以是静态方法和非静态方法,但是不能是抽象类的抽象方法,也不能是接口中的接口方法。下面代码是一个同步方法的示例:
- public synchronized void aMethod() {
- // do something
- }
- public static synchronized void anotherMethod() {
- // do something
- }
- public synchronized void aMethod() {
- // do something
- }
- public static synchronized void anotherMethod() {
- // do something
- }
public synchronized void aMethod() { // do something } public static synchronized void anotherMethod() { // do something }
线程在执行同步方法时是具有排它性的。当任意一个线程进入到一个对象的任意一个同步方法时,这个对象的所有同步方法都被锁定了,在此期间,其他任何线程都不能访问这个对象的任意一个同步方法,直到这个线程执行完它所调用的同步方法并从中退出,从而导致它释放了该对象的同步锁之后。在一个对象被某个线程锁定之后,其他线程是可以访问这个对象的所有非同步方法的。
同步块的形式虽然与同步方法不同,但是原理和效果是一致的。同步块是通过锁定一个指定的对象,来对同步块中包含的代码进行同步;而同步方法是对这个方法块里的代码进行同步,而这种情况下锁定的对象就是同步方法所属的主体对象自身。如果这个方法是静态同步方法呢?那么线程锁定的就不是这个类的对象了,也不是这个类自身,而是这个类对应的java.lang.Class类型的对象。同步方法和同步块之间的相互制约只限于同一个对象之间,所以静态同步方法只受它所属类的其它静态同步方法的制约,而跟这个类的实例(对象)没有关系。
下面这段代码演示了同步块的实现方式:
- public void test() {
- // 同步锁
- String lock = "LOCK";
- // 同步块
- synchronized (lock) {
- // do something
- }
- int i = 0;
- // ...
- }
- public void test() {
- // 同步锁
- String lock = "LOCK";
- // 同步块
- synchronized (lock) {
- // do something
- }
- int i = 0;
- // ...
- }
public void test() { // 同步锁 String lock = "LOCK"; // 同步块 synchronized (lock) { // do something } int i = 0; // ... }
对于作为同步锁的对象并没有什么特别要求,任意一个对象都可以。如果一个对象既有同步方法,又有同步块,那么当其中任意一个同步方法或者同步块被某个线程执行时,这个对象就被锁定了,其他线程无法在此时访问这个对象的同步方法,也不能执行同步块。
synchronized和Lock
Lock是一个接口,它位于Java 5.0新增的java.utils.concurrent包的子包locks中。concurrent包及其子包中的类都是用来处理多线程编程的。实现Lock接口的类具有与synchronized关键字同样的功能,但是它更加强大一些。java.utils.concurrent.locks.ReentrantLock是较常用的实现了Lock接口的类。下面是ReentrantLock类的一个应用实例:
- private Lock lock = new ReentrantLock();
- public void testLock() {
- // 锁定对象
- lock.lock();
- try {
- // do something
- } finally {
- // 释放对对象的锁定
- lock.unlock();
- }
- }
- private Lock lock = new ReentrantLock();
- public void testLock() {
- // 锁定对象
- lock.lock();
- try {
- // do something
- } finally {
- // 释放对对象的锁定
- lock.unlock();
- }
- }
private Lock lock = new ReentrantLock(); public void testLock() { // 锁定对象 lock.lock(); try { // do something } finally { // 释放对对象的锁定 lock.unlock(); } }
lock()方法用于锁定对象,unlock()方法用于释放对对象的锁定,他们都是在Lock接口中定义的方法。位于这两个方法之间的代码在被执行时,效果等同于被放在synchronized同步块中。一般用法是将需要在lock()和unlock()方法之间执行的代码放在try{}块中,并且在finally{}块中调用unlock()方法,这样就可以保证即使在执行代码抛出异常的情况下,对象的锁也总是会被释放,否则的话就会为死锁的产生增加可能。
使用synchronized关键字实现的同步,会把一个对象的所有同步方法和同步块看做一个整体,只要有一个被某个线程调用了,其他的就无法被别的线程执行,即使这些方法或同步块与被调用的代码之间没有任何逻辑关系,这显然降低了程序的运行效率。而使用Lock就能够很好地解决这个问题。我们可以把一个对象中按照逻辑关系把需要同步的方法或代码进行分组,为每个组创建一个Lock类型的对象,对实现同步。那么,当一个同步块被执行时,这个线程只会锁定与当前运行代码相关的其他代码最小集合,而并不影响其他线程对其余同步代码的调用执行。
关于死锁
死锁就是一个进程中的每个线程都在等待这个进程中的其他线程释放所占用的资源,从而导致所有线程都无法继续执行的情况。死锁是多线程编程中一个隐藏的陷阱,它经常发生在多个线程共用资源的时候。在实际开发中,死锁一般隐藏的较深,不容易被发现,一旦死锁现象发生,就必然会导致程序的瘫痪。因此必须避免它的发生。
程序中必须同时满足以下四个条件才会引发死锁:
- 互斥(Mutual exclusion):线程所使用的资源中至少有一个是不能共享的,它在同一时刻只能由一个线程使用。
- 持有与等待(Hold and wait):至少有一个线程已经持有了资源,并且正在等待获取其他的线程所持有的资源。
- 非抢占式(No pre-emption):如果一个线程已经持有了某个资源,那么在这个线程释放这个资源之前,别的线程不能把它抢夺过去使用。
- 循环等待(Circular wait):假设有N个线程在运行,第一个线程持有了一个资源,并且正在等待获取第二个线程持有的资源,而第二个线程正在等待获取第三个线程持有的资源,依此类推……第N个线程正在等待获取第一个线程持有的资源,由此形成一个循环等待。
线程池
线程池就像数据库连接池一样,是一个对象池。所有的对象池都有一个共同的目的,那就是为了提高对象的使用率,从而达到提高程序效率的目的。比如对于Servlet,它被设计为多线程的(如果它是单线程的,你就可以想象,当1000个人同时请求一个网页时,在第一个人获得请求结果之前,其它999个人都在郁闷地等待),如果为每个用户的每一次请求都创建一个新的线程对象来运行的话,系统就会在创建线程和销毁线程上耗费很大的开销,大大降低系统的效率。因此,Servlet多线程机制背后有一个线程池在支持,线程池在初始化初期就创建了一定数量的线程对象,通过提高对这些对象的利用率,避免高频率地创建对象,从而达到提高程序的效率的目的。
下面实现一个最简单的线程池,从中理解它的实现原理。为此我们定义了四个类,它们的用途及具体实现如下:
[list=1]
Task的定义如下:
- public abstract class Task {
- public enum State {
- /* 新建 */NEW, /* 执行中 */RUNNING, /* 已完成 */FINISHED
- }
- // 任务状态
- private State state = State.NEW;
- public void setState(State state) {
- this.state = state;
- }
- public State getState() {
- return state;
- }
- public abstract void deal();
- }
- public abstract class Task {
- public enum State {
- /* 新建 */NEW, /* 执行中 */RUNNING, /* 已完成 */FINISHED
- }
- // 任务状态
- private State state = State.NEW;
- public void setState(State state) {
- this.state = state;
- }
- public State getState() {
- return state;
- }
- public abstract void deal();
- }
public abstract class Task { public enum State { /* 新建 */NEW, /* 执行中 */RUNNING, /* 已完成 */FINISHED } // 任务状态 private State state = State.NEW; public void setState(State state) { this.state = state; } public State getState() { return state; } public abstract void deal(); }
TaskQueue类的定义如下:
- import java.util.Iterator;
- import java.util.LinkedList;
- import java.util.List;
- public class TaskQueue {
- private List<Task> queue = new LinkedList<Task>();
- // 添加一项任务
- public synchronized void addTask(Task task) {
- if (task != null) {
- queue.add(task);
- }
- }
- // 完成任务后将它从任务队列中删除
- public synchronized void finishTask(Task task) {
- if (task != null) {
- task.setState(Task.State.FINISHED);
- queue.remove(task);
- }
- }
- // 取得一项待执行任务
- public synchronized Task getTask() {
- Iterator<Task> it = queue.iterator();
- Task task;
- while (it.hasNext()) {
- task = it.next();
- // 寻找一个新建的任务
- if (Task.State.NEW.equals(task.getState())) {
- // 把任务状态置为运行中
- task.setState(Task.State.RUNNING);
- return task;
- }
- }
- return null;
- }
- }
- import java.util.Iterator;
- import java.util.LinkedList;
- import java.util.List;
- public class TaskQueue {
- private List<Task> queue = new LinkedList<Task>();
- // 添加一项任务
- public synchronized void addTask(Task task) {
- if (task != null) {
- queue.add(task);
- }
- }
- // 完成任务后将它从任务队列中删除
- public synchronized void finishTask(Task task) {
- if (task != null) {
- task.setState(Task.State.FINISHED);
- queue.remove(task);
- }
- }
- // 取得一项待执行任务
- public synchronized Task getTask() {
- Iterator<Task> it = queue.iterator();
- Task task;
- while (it.hasNext()) {
- task = it.next();
- // 寻找一个新建的任务
- if (Task.State.NEW.equals(task.getState())) {
- // 把任务状态置为运行中
- task.setState(Task.State.RUNNING);
- return task;
- }
- }
- return null;
- }
- }
import java.util.Iterator; import java.util.LinkedList; import java.util.List; public class TaskQueue { private List<Task> queue = new LinkedList<Task>(); // 添加一项任务 public synchronized void addTask(Task task) { if (task != null) { queue.add(task); } } // 完成任务后将它从任务队列中删除 public synchronized void finishTask(Task task) { if (task != null) { task.setState(Task.State.FINISHED); queue.remove(task); } } // 取得一项待执行任务 public synchronized Task getTask() { Iterator<Task> it = queue.iterator(); Task task; while (it.hasNext()) { task = it.next(); // 寻找一个新建的任务 if (Task.State.NEW.equals(task.getState())) { // 把任务状态置为运行中 task.setState(Task.State.RUNNING); return task; } } return null; } }
addTask(Task task)方法用于当一个新的任务到达时,将它添加到任务队列中。这里使用了LinkedList类来保存任务到达的先后顺序。finishTask(Task task)方法用于任务被执行完毕时,将它从任务队列中清除出去。getTask()方法用于取得当前要执行的任务。
- public class TaskThread extends Thread {
- // 该线程所属的线程池
- private ThreadPoolService service;
- public TaskThread(ThreadPoolService tps) {
- service = tps;
- }
- public void run() {
- // 在线程池运行的状态下执行任务队列中的任务
- while (service.isRunning()) {
- TaskQueue queue = service.getTaskQueue();
- Task task = queue.getTask();
- if (task != null) {
- task.deal();
- }
- queue.finishTask(task);
- }
- }
- }
- public class TaskThread extends Thread {
- // 该线程所属的线程池
- private ThreadPoolService service;
- public TaskThread(ThreadPoolService tps) {
- service = tps;
- }
- public void run() {
- // 在线程池运行的状态下执行任务队列中的任务
- while (service.isRunning()) {
- TaskQueue queue = service.getTaskQueue();
- Task task = queue.getTask();
- if (task != null) {
- task.deal();
- }
- queue.finishTask(task);
- }
- }
- }
public class TaskThread extends Thread { // 该线程所属的线程池 private ThreadPoolService service; public TaskThread(ThreadPoolService tps) { service = tps; } public void run() { // 在线程池运行的状态下执行任务队列中的任务 while (service.isRunning()) { TaskQueue queue = service.getTaskQueue(); Task task = queue.getTask(); if (task != null) { task.deal(); } queue.finishTask(task); } } }
ThreadPoolService类的定义如下:
- import java.util.ArrayList;
- import java.util.List;
- public class ThreadPoolService {
- // 线程数
- public static final int THREAD_COUNT = 5;
- // 线程池状态
- private Status status = Status.NEW;
- private TaskQueue queue = new TaskQueue();
- public enum Status {
- /* 新建 */NEW, /* 提供服务中 */RUNNING, /* 停止服务 */TERMINATED,
- }
- private List<Thread> threads = new ArrayList<Thread>();
- public ThreadPoolService() {
- for (int i = 0; i < THREAD_COUNT; i++) {
- Thread t = new TaskThread(this);
- threads.add(t);
- }
- }
- // 启动服务
- public void start() {
- this.status = Status.RUNNING;
- for (int i = 0; i < THREAD_COUNT; i++) {
- threads.get(i).start();
- }
- }
- // 停止服务
- public void stop() {
- this.status = Status.TERMINATED;
- }
- // 是否正在运行
- public boolean isRunning() {
- return status == Status.RUNNING;
- }
- // 执行任务
- public void runTask(Task task) {
- queue.addTask(task);
- }
- protected TaskQueue getTaskQueue() {
- return queue;
- }
- }
- import java.util.ArrayList;
- import java.util.List;
- public class ThreadPoolService {
- // 线程数
- public static final int THREAD_COUNT = 5;
- // 线程池状态
- private Status status = Status.NEW;
- private TaskQueue queue = new TaskQueue();
- public enum Status {
- /* 新建 */NEW, /* 提供服务中 */RUNNING, /* 停止服务 */TERMINATED,
- }
- private List<Thread> threads = new ArrayList<Thread>();
- public ThreadPoolService() {
- for (int i = 0; i < THREAD_COUNT; i++) {
- Thread t = new TaskThread(this);
- threads.add(t);
- }
- }
- // 启动服务
- public void start() {
- this.status = Status.RUNNING;
- for (int i = 0; i < THREAD_COUNT; i++) {
- threads.get(i).start();
- }
- }
- // 停止服务
- public void stop() {
- this.status = Status.TERMINATED;
- }
- // 是否正在运行
- public boolean isRunning() {
- return status == Status.RUNNING;
- }
- // 执行任务
- public void runTask(Task task) {
- queue.addTask(task);
- }
- protected TaskQueue getTaskQueue() {
- return queue;
- }
- }
import java.util.ArrayList; import java.util.List; public class ThreadPoolService { // 线程数 public static final int THREAD_COUNT = 5; // 线程池状态 private Status status = Status.NEW; private TaskQueue queue = new TaskQueue(); public enum Status { /* 新建 */NEW, /* 提供服务中 */RUNNING, /* 停止服务 */TERMINATED, } private List<Thread> threads = new ArrayList<Thread>(); public ThreadPoolService() { for (int i = 0; i < THREAD_COUNT; i++) { Thread t = new TaskThread(this); threads.add(t); } } // 启动服务 public void start() { this.status = Status.RUNNING; for (int i = 0; i < THREAD_COUNT; i++) { threads.get(i).start(); } } // 停止服务 public void stop() { this.status = Status.TERMINATED; } // 是否正在运行 public boolean isRunning() { return status == Status.RUNNING; } // 执行任务 public void runTask(Task task) { queue.addTask(task); } protected TaskQueue getTaskQueue() { return queue; } }
[/list]
完成了上面四个类,我们就实现了一个简单的线程池。现在我们就可以使用它了,下面的代码做了一个简单的示例:
发表评论
-
Java 反射实例
2012-12-21 11:19 1389import java.lang.reflect.Met ... -
java.lang.IndexOutOfBoundsException: replaceAll 转义
2012-12-12 13:10 1226java.lang.IndexOutOfBoundsEx ... -
Java 设计模式
2012-09-25 22:19 3707Java设计模式-图解-附代码 ... -
Java 基础学习
2012-09-25 22:17 955Java语言基础 谈到Java语言基础学习的书籍, ... -
转载的一篇关于如何优化JAVA代码及提高效率的文章
2012-09-23 09:49 2204可供程序利用的资源(内存、CPU时间、网络带宽等)是有限 ... -
面向对象
2012-09-21 21:04 960重写方法规则如下: * 变元 ... -
声明和访问控制
2012-09-19 09:00 1095Java合法标识符规范 (1)标识符必须以字母,货币符 ... -
break continue 用法
2012-09-07 08:48 11121.一般的用法:continue 和break用于跳出循 ... -
Java线程唤醒与阻塞
2012-09-01 17:09 18337阻塞指的是暂停一个线 ... -
用Java实现常用排序算法
2012-09-01 17:02 890package com.zhaopin; publ ... -
JAVA面试宝典-05
2012-08-22 22:25 1162101、java中会存在内存泄 ... -
JAVA面试宝典-04
2012-08-22 22:18 87371、简述synchronized和java. ... -
JAVA面试宝典-03
2012-08-22 22:16 93751、垃圾回收的优点和 ... -
JAVA面试宝典-02
2012-08-22 22:14 95611、HashMap和Hashtable的区别。 HashM ... -
JAVA面试宝典-01
2012-08-22 22:11 9241、String是最基本的数据 ... -
JAVA 3D 开发
2012-04-17 09:36 1581import java.applet.Applet ... -
fatJar 安装与使用
2012-04-06 21:50 2159打包成双击可执行的jar文件。 推荐插件:fat ... -
Java 初始化
2011-10-22 10:54 1024Java中方法的局部变量必须要初始化,否则不能使用和操作, ... -
Java 清理
2011-10-22 10:03 931在static方法内部不能调用非静态方法,反过来是可以的。 ... -
Java 构造器
2011-10-22 09:15 810在构造其中可以用this调用一个构造器,但却不能调用两个。 ...
相关推荐
Java同步网络时间是一个常见的任务,尤其对于需要时间精确性的应用来说非常重要。这个任务可以通过Java的NTP(Network Time Protocol)库来实现。NTP是一种互联网协议,用于在计算机之间同步时间,确保网络上的设备...
### Java同步机制浅谈 #### synchronized关键字的作用及应用 在Java多线程环境中,`synchronized`关键字扮演着至关重要的角色。它可以帮助开发者确保多线程环境下的数据一致性,防止因并发访问导致的数据错误。本...
Java同步与异步 Java同步与异步是Java编程中非常重要的概念,它们都是为了解决多线程环境中的线程安全问题。在多线程环境中,如果没有正确的同步机制,多个线程可能会同时访问共享资源,导致数据不一致和其他严重...
java同步大杀器concurrent 包java同步大杀器concurrent 包java同步大杀器concurrent 包java同步大杀器concurrent 包java同步大杀器concurrent 包java同步大杀器concurrent 包java同步大杀器concurrent 包java同步大...
Java同步机制是多线程编程中确保数据一致性与正确性的关键。在Java中,主要有两种同步机制:内置的`synchronized`关键字以及基于`java.util.concurrent`包中的高级同步工具类。本文将深入探讨这些机制的底层实现,...
Java同步歌词功能是一种在音乐播放器中常见的特性,它允许用户在欣赏音乐的同时,看到与当前播放时间对应的歌词。这项功能的实现主要依赖于Java编程语言以及对LRC(Lyric Repeat Character)格式的文本文件处理。LRC...
Java中的`synchronized`关键字是多线程编程中的一个重要概念,用于控制并发访问共享资源时的同步机制。在Java中,当多个线程试图同时访问和修改同一块代码或数据时,可能会导致数据不一致的问题。为了解决这个问题,...
Java 同步器 SynchronousQueue 详解及实例 Java 中的同步器 SynchronousQueue 是一种特殊的阻塞队列,它最多只能放一个元素,这个元素如果不在特定的时间消费掉就会被删除,队列的长度始终为 0。SynchronousQueue ...
Java 同步锁是Java多线程编程中的关键概念,用于确保多个线程在访问共享资源时能够有序、安全地进行。在这个主题中,我们将详细探讨Java中的同步机制,包括同步方法、同步代码块、synchronized关键字以及其背后的...
Java同步是Java编程中一个非常重要的概念,主要涉及到多线程环境下的程序控制。在Java中,当多个线程同时访问共享资源时,如果没有适当的同步机制,可能会导致数据不一致、竞态条件等问题。同步机制确保了在特定时间...
### Java同步和内存模型 #### 一、引言与背景 在探讨Java的同步机制及其内存模型之前,我们首先理解一下为什么需要这两种机制。在单线程环境下,程序的执行通常按照顺序进行,编译器、处理器等底层硬件组件虽然会...
【Java 同步方法】是Java编程中...总之,理解和优化Java同步方法的使用,是提高多线程应用程序性能和可伸缩性的核心。通过精细调整同步策略,可以有效地减少争用,提升并发性能,从而让程序在高负载环境下表现更佳。
Java同步线程模型分析与改进 本文讨论了Java同步线程模型的缺陷和改进方法。Java是一种支持多线程编程的语言,但是在实际应用中,Java的线程模型存在一些缺陷,例如同步问题。目前,普遍采用急救包(Band-Aid)类库...
在本文中,我们将从多个角度深入探讨Java同步线程模型,并提出相应的改进措施,以期进一步提高Java语言的并发编程效率。 首先,对于Java同步线程模型的理解,可以从与传统的多进程模式的对比中得到启发。进程与进程...
【Java同步之synchronized解析】 Java中的`synchronized`关键字是实现多线程同步的重要机制,它确保了在并发环境中对共享资源的访问是线程安全的。以下是对`synchronized`的详细解读: ### 1. synchronized的特性 ...
### Java同步线程模型分析与改进 #### 一、引言 随着软件系统变得越来越复杂,多线程编程成为提高程序性能和响应性的关键手段之一。Java作为一种广泛使用的编程语言,自诞生以来就内置了对多线程的支持。然而,...
首先,Java同步主要指的是通过特定机制(如`synchronized`关键字、`Lock`接口等)来控制多个线程对共享资源的访问,以避免竞态条件。竞态条件是指当两个或更多线程可以同时修改同一变量,且结果取决于它们的执行顺序...
本文旨在分析Java同步线程模型的优缺点,并提出相应的改进措施。 Java同步线程模型的核心优势在于其能够显著提高系统并发执行的程度。同步机制使得并发程序能够有序地访问共享资源,从而有效避免了数据竞争和状态不...
Java同步歌词显示,让你熟悉JAppelet的用法
在这个“关于CoreJava同步的疑惑例子”中,我们将探讨Java中的同步机制,以及如何通过示例代码`Bank.java`, `TransferRunnable.java`, 和 `SynchBankTest.java`来理解这个概念。 1. **同步的必要性** 当多个线程...