Java并发编程第二章
- 格式：pdf
- 大小：360.26 KB
- 文档页数：20
下载文档原格式
合集下载
JAVA教程第2章(控制台程序设计)
Java程序运行环境架构
Java源代码 (.java文件)
Java编译器 JVM
Java字节码 (.class文件)
装载器
操作系统/ 硬件平台
字节校验器
Java解释器
JVM
虚拟机——用软件构造出来的计算机。它是通过在实际的计算机上仿真模拟各
种计算机功能来实现的。虚拟机有自己的指令系统，但没有硬件，它把虚拟代 码转换成相应的机器代码，再加以执行。
第2章 控制台程序设计
本章提要
◆ ◆ ◆ ◆ 面向对象思想 Java语言特点 Java运行环境 编写Java程序
本章知识要点
Java程序分类 Java开发环境与运行 类的定义 类的四个基本特性 接口
任务1 认识Java程序及其运行
什么是Java程序 Java开发环境及工具 计算机处理Java程序的过程
Java程序
例子: /* WelcomeApp.java*/ import ng.System; class WelcomeApp { public static void main(String args[]) { System.out.println("Welcome to Java World!"); } }
任务2 编写数字显示程序
问题分析 知识学习
类的抽象与封装 数据类型 常用类和包 定义Java类
任务实施
问题分析
任务描述：
编写一个程序，能够显示数字
问题分析：
Java程序构成,它是面向对象的语言,其程序由类组成的,需要了解类
的相关概念
编写Java程序的方法和步骤 确定显示数字所使用的数据类型,了解数据类型知识 编写代码 编译执行
Java开发中的并发编程
Java开发中的并发编程随着计算机运算能力的不断提升，对于多线程处理的需求也日益增加。
在Java开发中，通过并发编程可以实现多个线程同时运行的效果，从而帮助程序实现高效、稳定、高可用的特点。
本文将从以下三个方面介绍Java开发中的并发编程。
一、Java多线程Java多线程是指在同一个程序中，允许有多个执行线程来分别执行不同的任务。
与单线程模式相比，多线程模式在程序处理的速度和效率上有很大的优势。
在Java中，实现多线程的方式有两种：继承Thread类和实现Runnable接口。
1. 继承Thread类继承Thread类后，需要重写run方法，run方法中的代码将在新线程中执行。
下面是一个简单的示例代码：```class MyThread extends Thread {public void run() {System.out.println("MyThread running");}}public class Main {public static void main(String[] args) {MyThread myThread = new MyThread();myThread.start();}}```2. 实现Runnable实现Runnable接口可以避免单继承的限制，这种方式一般比继承Thread类更为常用。
下面是一个简单的示例代码：```class MyRunnable implements Runnable {public void run() {System.out.println("MyRunnable running");}}public class Main {public static void main(String[] args) {MyRunnable myRunnable = new MyRunnable(); Thread thread = new Thread(myRunnable);thread.start();}}```二、Java线程安全在多线程并发操作中，需要考虑线程安全问题，否则可能会产生数据异常或者程序崩溃的情况。
《Java并发编程指南》
《Java并发编程指南》Java并发编程指南Java是一种高级编程语言，它的并发机制常常被人们称为其最大的优势之一。
Java中的并发编程可以让程序员灵活地利用多线程来处理各种任务，并在运行时高效地使用系统资源。
Java并发编程的设计理念和实现方式也变得越来越成熟，已经成为Java开发人员必须掌握的技能之一。
本文的主要内容是Java并发编程指南，它包括以下几个方面：第一、Java并发编程涉及的基本概念。
Java并发编程中涉及的基本概念包括多线程的概念和线程池的概念。
多线程是指在同一个进程里同时执行多个线程，并行执行，每个线程有自己的独立的执行体和执行上下文。
线程池是一种可重用的线程资源集合，可以提高程序的并发运行效率，避免不必要的系统开销，并提供了线程管理的功能。
第二、Java并发编程的核心技术。
Java并发编程的核心技术主要包括同步、锁和原子操作。
同步是指多个线程在相同的互斥区域中执行时为了保证数据一致性而相互协作的机制。
锁是一种用于保护共享资源的机制，可以使得同一时刻只有一个线程访问共享资源。
原子操作是指只能被一次性执行完毕的操作，例如加减乘除等算术运算，或者更新数据等操作。
第三、Java并发编程的实践技巧。
Java并发编程的实践技巧包括遵循最佳实践、线程安全的实践、并发编程的调试技巧和在Java EE中使用并发编程的实现技巧。
遵循最佳实践可以使得程序线程安全，可维护、可扩展和稳定。
线程安全的实践指的是保证程序的正确性和健壮性，避免出现数据的污染和竞争问题。
并发编程的调试技巧可以有效地发现和解决程序中的问题。
在Java EE中使用并发编程的实现技巧需要特别关注合理使用线程池和优化Hibernate ORM框架的使用。
四、Java并发编程的代码实现。
Java并发编程的代码实现可以分为基于线程的实现和基于执行器的实现两个方面。
基于线程的实现需要手动创建线程并管理线程的状态和执行。
基于执行器的实现则是利用Java中的线程池框架来自动管理线程的创建和销毁，并且更容易实现任务的分配和优化。
Java并发编程ArrayBlockingQueue的实现
Java并发编程ArrayBlockingQueue的实现⼀、简介ArrayBlockingQueue 顾名思义：基于数组的阻塞队列。
数组是要指定长度的，所以使⽤ ArrayBlockingQueue 时必须指定长度，也就是它是⼀个有界队列。
它实现了 BlockingQueue 接⼝，有着队列、集合以及阻塞队列的所有⽅法。
ArrayBlockingQueue 是线程安全的，内部使⽤ ReentrantLock 来保证。
ArrayBlockingQueue ⽀持对⽣产者线程和消费者线程进⾏公平的调度。
当然默认情况下是不保证公平性的，因为公平性通常会降低吞吐量，但是可以减少可变性和避免线程饥饿问题。
⼆、数据结构通常，队列的实现⽅式有数组和链表两种⽅式。
对于数组这种实现⽅式来说，我们可以通过维护⼀个队尾指针，使得在⼊队的时候可以在 O(1)O(1) 的时间内完成；但是对于出队操作，在删除队头元素之后，必须将数组中的所有元素都往前移动⼀个位置，这个操作的复杂度达到了 O(n)O(n)，效果并不是很好。
如下图所⽰：为了解决这个问题，我们可以使⽤另外⼀种逻辑结构来处理数组中各个位置之间的关系。
假设现在我们有⼀个数组 A[1…n]，我们可以把它想象成⼀个环型结构，即 A[n] 之后是 A[1]，相信了解过⼀致性 Hash 算法的童鞋应该很容易能够理解。
如下图所⽰：我们可以使⽤两个指针，分别维护队头和队尾两个位置，使⼊队和出队操作都可以在 O(1O(1 )的时间内完成。
当然，这个环形结构只是逻辑上的结构，实际的物理结构还是⼀个普通的数组。
讲完 ArrayBlockingQueue 的数据结构，接下来我们从源码层⾯看看它是如何实现阻塞的。
三、源码分析3.1 属性// 队列的底层结构final Object[] items;// 队头指针int takeIndex;// 队尾指针int putIndex;// 队列中的元素个数int count;final ReentrantLock lock;// 并发时的两种状态private final Condition notEmpty;private final Condition notFull;items 是⼀个数组，⽤来存放⼊队的数据；count 表⽰队列中元素的个数；takeIndex 和 putIndex 分别代表队头和队尾指针。
Java高级程序设计(第二版) 第2章 异常处理
<class> <自定义异常类名> <extends> <Exception>{ // 变量、构造方法、成员方法 }
二、throw关键字
<throw> <异常对象&g 使用throws关键字
编程实现与任务3相同的根据分数判定等级并输出的功能。 代码要求：将根据分数判等级的功能定义为方法，且方法内 部不处理分数异常，而是将异常抛出给其调用者来进行处理。
一、异常的概念
程序开发中一般会出现两种问题：
• 第一种，在编译期间被检测出来的错误，我们称之为语法错误，
比如关键字拼写错误、语句丢失分号、变量名未定义等。如果
程序中存在这类错误，将不能编译通过，不能生成字节码。
• 第二种，没有语法错误编译成功了，但在程序运行期间出现错 误，我们称之为运行错误，比如被访问对象没有正常初始化、 访问数组元素时下标值超出范围等等。这种运行错误如果没有 得到及时的处理，可能会造成程序提前中断、数据遗失乃至系 统崩溃等问题。这种运行错误也就是我们所说的“异常”。
的钱的尝试时。
（2）InvalidDepositException：当无效钱数（小于0）存入时。
NoSuchUserException，当用户名正确而password和类成员变量
password不相符时抛出自定义异常PasswordDontMatchException。
实训任务
[实训 2-2]
创建帐户类，其中定义存钱、取钱、查询余额等三个方法，并自定义如
下异常类型用于账户类：
（1）AccountOverdrawnException：当有了这个要取出比帐户上更多
本章任务
• 任务1 识别异常 • 任务2 处理异常
二、throw关键字
<throw> <异常对象&g 使用throws关键字
编程实现与任务3相同的根据分数判定等级并输出的功能。 代码要求：将根据分数判等级的功能定义为方法，且方法内 部不处理分数异常，而是将异常抛出给其调用者来进行处理。
一、异常的概念
程序开发中一般会出现两种问题：
• 第一种，在编译期间被检测出来的错误，我们称之为语法错误，
比如关键字拼写错误、语句丢失分号、变量名未定义等。如果
程序中存在这类错误，将不能编译通过，不能生成字节码。
• 第二种，没有语法错误编译成功了，但在程序运行期间出现错 误，我们称之为运行错误，比如被访问对象没有正常初始化、 访问数组元素时下标值超出范围等等。这种运行错误如果没有 得到及时的处理，可能会造成程序提前中断、数据遗失乃至系 统崩溃等问题。这种运行错误也就是我们所说的“异常”。
的钱的尝试时。
（2）InvalidDepositException：当无效钱数（小于0）存入时。
NoSuchUserException，当用户名正确而password和类成员变量
password不相符时抛出自定义异常PasswordDontMatchException。
实训任务
[实训 2-2]
创建帐户类，其中定义存钱、取钱、查询余额等三个方法，并自定义如
下异常类型用于账户类：
（1）AccountOverdrawnException：当有了这个要取出比帐户上更多
本章任务
• 任务1 识别异常 • 任务2 处理异常
Java语言并发编程实战
Java语言并发编程实战1. 引言介绍Java语言的并发编程概念和重要性，在当今多核处理器的背景下，利用并发编程可以实现更高效和更灵活的软件开发。
2. 并发编程基础2.1 线程与进程解释线程与进程的区别，并介绍Java中的线程概念。
2.2 共享资源与竞态条件说明共享资源在并发编程中的问题，并解释竞态条件的概念。
2.3 同步与互斥探讨使用同步和互斥来解决并发编程中的竞态条件问题。
3. Java并发编程模型3.1 线程创建与启动介绍如何在Java中创建和启动线程。
3.2 线程安全性解释线程安全性的定义，并介绍线程安全性的实现方法。
3.3 锁介绍Java中的锁概念以及常用的锁类型，如synchronized和ReentrantLock。
3.4 并发集合类介绍Java中的并发集合类，如ConcurrentHashMap和ConcurrentLinkedQueue，用于解决多线程并发访问问题。
3.5 并发工具类介绍Java中的并发工具类，如CountDownLatch和CyclicBarrier，用于简化并发编程的实现。
4. 并发编程实践4.1 线程安全的Singleton模式探讨在多线程环境下实现线程安全的Singleton模式。
4.2 生产者-消费者模型介绍如何使用Java并发编程实现生产者-消费者模型。
4.3 并发排序算法解释如何使用并发编程思想改进排序算法的性能。
4.4 线程池的使用介绍如何使用Java中的线程池来管理和调度线程。
5. 并发编程的注意事项与挑战5.1 死锁解释死锁的概念，并提供避免死锁的方法。
5.2 竞态条件与活跃性问题说明竞态条件和活跃性问题的潜在风险，并给出解决方案。
5.3 性能与伸缩性探讨并发编程在性能和伸缩性方面可能遇到的挑战，并提供解决思路和技术。
6. 结论总结Java语言并发编程的重要性和实践方法，并强调并发编程的潜在风险和注意事项。
7. 参考文献列出本文引用的相关文献和资源。
jAVA2程序设计基础第二章精品PPT课件
Java中整型常量可以分为十进制、十六进制和八进制。而整型变量的 定义可分为四种：byte型、short型、int型和long型。 4. 浮点类型
浮点类型可分为 float(32位)和double(64位)两种类型。float 型叫做单 精度浮点数。
返回
2.1.4 Java中的命名规则
一般来说，变量命名只要按照标识符的命名规则来命名即可，但为了 程序更加规范和易读，在Java语言规范中有以下命名规则：
返回
2.1.3 Java语言中的基本数据类型
1. 逻辑类型 逻辑类型又称布尔类型，其值只有两种：真(true)和假(false)。它使用
关键字boolean 来定义逻辑变量。 2. 字符类型
Java中每一个字符占两个字节，它使用的是unicode字符集，因此可 使用的常量共有65535个。它使用关键字char来定义字符变量。 3. 整数类型
第2章 Java编程基础
教学提示：在上一章中，我们对Java语言的历史、原理、开发环 境的搭建和系统环境变量的设置进行了介绍，使读者对其有一个基本 的了解。但仅仅掌握这些还不够。本章将进一步介绍Java语言程序设计 的方法与技巧，任何技巧和能力的形成都是以基础知识作为铺垫的， 因此本章把注意力集中在Java语言最基础的知识方面，这涉及到数据类 型以及定义在其上的运算、表达式、基本语法格式、变量及变量的作 用域和运算符等。学习这些内容后，读者对Java语言会有一个更深的了 解。
返回
2.1.5 Java中的一些注意事项
(1) Java是要区分大小写的。 (2) 功能执行语句的后面必须以分号(;)结束，这是提示该执行语句 结束的标志，而且这个分号是英文的(;)而不能是中文的(；)。
返回
2.2 变量及变量的作用域
浮点类型可分为 float(32位)和double(64位)两种类型。float 型叫做单 精度浮点数。
返回
2.1.4 Java中的命名规则
一般来说，变量命名只要按照标识符的命名规则来命名即可，但为了 程序更加规范和易读，在Java语言规范中有以下命名规则：
返回
2.1.3 Java语言中的基本数据类型
1. 逻辑类型 逻辑类型又称布尔类型，其值只有两种：真(true)和假(false)。它使用
关键字boolean 来定义逻辑变量。 2. 字符类型
Java中每一个字符占两个字节，它使用的是unicode字符集，因此可 使用的常量共有65535个。它使用关键字char来定义字符变量。 3. 整数类型
第2章 Java编程基础
教学提示：在上一章中，我们对Java语言的历史、原理、开发环 境的搭建和系统环境变量的设置进行了介绍，使读者对其有一个基本 的了解。但仅仅掌握这些还不够。本章将进一步介绍Java语言程序设计 的方法与技巧，任何技巧和能力的形成都是以基础知识作为铺垫的， 因此本章把注意力集中在Java语言最基础的知识方面，这涉及到数据类 型以及定义在其上的运算、表达式、基本语法格式、变量及变量的作 用域和运算符等。学习这些内容后，读者对Java语言会有一个更深的了 解。
返回
2.1.5 Java中的一些注意事项
(1) Java是要区分大小写的。 (2) 功能执行语句的后面必须以分号(;)结束，这是提示该执行语句 结束的标志，而且这个分号是英文的(;)而不能是中文的(；)。
返回
2.2 变量及变量的作用域
Java语言中的并发编程
Java语言中的并发编程Java是一种广泛使用的编程语言，它广泛应用于许多不同的领域。
在本文中，我将重点讨论Java语言中的并发编程。
并发编程是指让计算机执行多个任务的能力，使计算机能够同时处理多个任务。
在Java中，我们可以使用多个线程来实现并发编程。
Java的并发编程方式Java中有两种使用线程的方式。
第一种是继承Thread类并覆盖run()方法。
第二种方法是实现Runnable接口并实现run()方法。
两种方法的效果相同，但第二种方法更普遍使用，因为它允许一个类以多种方式实现。
Java中的线程同步当多个线程同时访问共享资源时，就需要确保线程的安全性。
线程同步是一种机制，确保多个线程可以共享相同的内存空间，不会产生竞争条件。
Java中有几种线程同步方式可用。
其中最常使用的方式是使用synchronized关键字。
这个关键字可以用于方法或代码块中，在它们的声明中包含了一个对象或Class对象，以确保在任何时候，只有一个线程访问该对象或Class对象。
另一个用于线程同步的Java构造是Locks。
锁允许您处理死锁的情况，并为线程同步提供另一种机制。
Java中的线程池Java中的线程池是一种机制，它可以在JVM中重复使用线程，以避免创建和销毁线程的开销。
这可以在许多并发编程方案中提高性能，并减少内存使用。
Java中的线程池有三种类型。
一种是FixedThreadPool，它在构造时创建固定数量的线程；第二种是CachedThreadPool，它根据需要创建新线程；最后一种是ScheduledThreadPool，它可以在指定的时间间隔内执行任务。
Java中的线程通信Java中的线程通信涉及到在多个线程之间传递数据。
Java提供了几种机制，以实现这种线程之间的通信。
其中最常见的是wait()，notify()和notifyAll()方法。
wait()方法用于暂停当前线程，直到其他线程调用notify()方法。
Java程序设计第二章
3）创建类成员变量；
4）调用类成员。
ቤተ መጻሕፍቲ ባይዱ
2.1.2 情境分析
面向对象程序设计采用模拟现实社会理解事物的思考思维 ，有利于提高程序员的编程效率。 就情景描述中的A类员工信息，对于员工编号、姓名、性 别等这些数据都是员工固有的属性；同时除了认识A类员 工的属性以外，还需要考虑A类员工能够做什么事情，比 如他能够晋升职称，随着时间的推移工龄能够增长等，这 就是A类员工具备的行为。
2.1.3 解决方案
package com.esms; public class EmployeeA { String employeeNo;//工号 String employeeName;//姓名 String employeeGender;//性别 String employeeDepartment;//所属部门 String employeePos;//职务 String employeeTitlePos;//职称 String employeeWorkYears;//工龄 public void display(){ System.out.println("员工编号："+this.employeeNo); System.out.println("员工姓名："+this.employeeName); System.out.println("员工性别："+this.employeeGender); System.out.println("员工所在部门： "+this.employeeDepartment); System.out.println("员工职务："+this.employeePos); System.out.println("员工职称："+this. employeeTitlePos); System.out.println("员工工龄："+this.employeeWorkYears); } public static void main(String[] args) { EmployeeA objTom=new EmployeeA(); //为Tom的主要属性赋值 objTom.employeeNo="00101"; objTom.employeeName="汤姆"; objTom.employeeGender="男"; objTom.employeeDepartment="技术一部"; objTom.employeePos="程序员"; objTom.employeeTitlePos ="助理工程师"; objTom.employeeWorkYears=1; //利用 objTom.display(); } }
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
第2章构建线程安全应用程序第二章构建线程安全应用程序.................................................................12.1.什么是线程安全性...........................................................................................................22.2.Servlet的线程安全性.......................................................................................................52.3.同步与互斥.......................................................................................................................92.3.1线程干扰...............................................................................................................92.3.2同步.....................................................................................................................11
2.4.同步与volatile.................................................................................................................132.5.活性................................................................................................................................14
2.6.ThreadLocal变量............................................................................................................152.7.高级并发对象.................................................................................................................19参考文献....................................................................................................................................202.1.什么是线程安全性当对一个复杂对象进行某种操作时，从操作开始到操作结束，被操作的对象往往会经历若干非法的中间状态。这跟外科医生做手术有点像，尽管手术的目的是改善患者的健康，但医生把手术过程分成了几个步骤，每个步骤如果不是完全结束的话，都会严重损害患者的健康。想想看，如果一个医生切开患者的胸腔后要休三周假会怎么样？与此类似，调用一个函数（假设该函数是正确的）操作某对象常常会使该对象暂时陷入不可用的状态（通常称为不稳定状态），等到操作完全结束，该对象才会重新回到完全可用的状态。如果其他线程企图访问一个处于不可用状态的对象，该对象将不能正确响应从而产生无法预料的结果，如何避免这种情况发生是线程安全性的核心问题。单线程的程序中是不存在这种问题的，因为在一个线程更新某对象的时候不会有其他线程也去操作同一个对象。（除非其中有异常，异常是可能导致上述问题的。当一个正在更新某对象的线程因异常而中断更新过程后，再去访问没有完全更新的对象，会出现同样的问题）给线程安全下定义是比较困难的。很多正式的定义都比较复杂。如，有这样的定义：“一个类在可以被多个线程安全调用时就是线程安全的”。但是它不能帮助我们区分一个线程安全的类与一个线程不安全的类。实际上，所有线程安全的定义都有某种程序的循环，因为它必须符合类的规格说明——这是对类的功能、其副作用、哪些状态是有效和无效的、不可变量、前置条件、后置条件等等的一种非正式的松散描述(由规格说明给出的对象状态约束只应用于外部可见的状态，即那些可以通过调用其公共方法和访问其公共字段看到的状态，而不应用于其私有字段中表示的内部状态)[1]。类要成为线程安全的，首先必须在单线程环境中有正确的行为。如果一个类实现正确(这是说它符合规格说明的另一种方式)，那么没有一种对这个类的对象的操作序列(读或者写公共字段以及调用公共方法)可以让对象处于无效状态，观察到对象处于无效状态、或者违反类的任何不可变量、前置条件或者后置条件的情况。此外，一个类要成为线程安全的，在被多个线程访问时，不管运行时环境执行这些线程有什么样的时序安排或者交错，它必须仍然有如上所述的正确行为，并且在调用的代码中没有任何额外的同步。其效果就是，在所有线程看来，对于线程安全对象的操作是以固定的、全局一致的顺序发生的。正确性与线程安全性之间的关系非常类似于在描述ACID(原子性、一致性、独立性和持久性)事务时使用的一致性与独立性之间的关系：从特定线程的角度看，由不同线程所执行的对象操作是先后(虽然顺序不定)而不是并行执行的。考虑下面的代码片段，它迭代一个Vector中的元素。尽管Vector的所有方法都是同步的，但是在多线程的环境中不做额外的同步就使用这段代码仍然是不安全的，因为如果另一个线程恰好在错误的时间里删除了一个元素，则get()会抛出一个ArrayIndexOutOfBoundsException。Vectorv=newVector();//containsraceconditions--mayrequireexternalsynchronizationfor(inti=0;idoSomething(v.get(i));}这里发生的事情是：get(index)的规格说明里有一条前置条件要求index必须是非负的
并且小于size()。但是，在多线程环境中，没有办法可以知道上一次查到的size()值是否仍然有效，因而不能确定isize()后独占地锁定Vector。
更明确地说，这一问题是由get()的前置条件是以size()的结果来定义的这一事实所带
来的。只要看到这种必须使用一种方法的结果作为另一种讲法的输入条件的样式，它就是一个状态依赖，就必须保证至少在调用这两种方法期间元素的状态没有改变。一般来说，做到这一点的唯一方法在调用第一个方法之前是独占性地锁定对象，一直到调用了后一种方法以后。在上面的迭代Vector元素的例子中，您需要在迭代过程中同步Vector对象。如上面的例子所示，线程安全性不是一个非真即假的命题。Vector的方法都是同步的，并且Vector明确地设计为在多线程环境中工作。但是它的线程安全性是有限制的，即在某些方法之间有状态依赖(类似地，如果在迭代过程中Vector被其他线程修改，那么由
Vector.iterator()返回的iterator会抛出ConcurrentModificationException)。对于Java类中常见的线程安全性级别，没有一种分类系统可被广泛接受，不过重要的是在编写类时尽量记录下它们的线程安全行为。Bloch给出了描述五类线程安全性的分类方法：不可变、线程安全、有条件线程安全、线程兼容和线程对立。只要明确地记录下线程安全特性，那么您是否使用这种系统都没关系。这种系统有其局限性——各类之间的界线不是百分之百地明确，而且有些情况它没照顾到,但是这套系统是一个很好的起点。这种分类系统的核心是调用者是否可以或者必须用外部同步包围操作(或者一系列操作)。下面分别描述了线程安全性的这五种类别。1)不可变不可变的对象一定是线程安全的，并且永远也不需要额外的同步。因为一个不可变的对象只要构建正确，其外部可见状态永远也不会改变，永远也不会看到它处于不一致的状态。Java类库中大多数基本数值类如Integer、String和BigInteger都是不可变的。2)线程安全由类的规格说明所规定的约束在对象被多个线程访问时仍然有效，不管运行时环境如何排列，线程都不需要任何额外的同步。这种线程安全性保证是很严格的——许多类，如Hashtable或者Vector都不能满足这种严格的定义。3)有条件的线程安全有条件的线程安全类对于单独的操作可以是线程安全的，但是某些操作序列可能需要外部同步。条件线程安全的最常见的例子是遍历由Hashtable或者Vector或者返回的迭代器——由这些类返回的fail-fast迭代器假定在迭代器进行遍历的时候底层集合不会有变化。为了保证其他线程不会在遍历的时候改变集合，进行迭代的线程应该确保它是独占性地访问集合以实现遍历的完整性。通常，独占性的访问是由对锁的同步保证的——并且类的文档应该说明是哪个锁(通常是对象的内部监视器(intrinsicmonitor))。如果对一个有条件线程安全类进行记录，那么您应该不仅要记录它是有条件线程安全的，而且还要记录必须防止哪些操作序列的并发访问。用户可以合理地假设其他操作序列不需要任何额外的同步。4)线程兼容线程兼容类不是线程安全的，但是可以通过正确使用同步而在并发环境中安全地使用。这可能意味着用一个synchronized块包围每一个方法调用，或者创建一个包装器对象，其中每一个方法都是同步的(就像Collections.synchronizedList()一样)。也可能意味着用
synchronized块包围某些操作序列。为了最大程度地利用线程兼容类，如果所有调用都使用同一个块，那么就不应该要求调用者对该块同步。这样做会使线程兼容的对象作为变量实例包含在其他线程安全的对象中，从而可以利用其所有者对象的同步。许多常见的类是线程兼容的，如集合类ArrayList和HashMap、java.text.SimpleDateFormat、或者JDBC类Connection和ResultSet。5)线程对立线程对立类是那些不管是否调用了外部同步都不能在并发使用时安全地呈现的类。线程对立很少见，当类修改静态数据，而静态数据会影响在其他线程中执行的其他类的行为，这