软件构造（JAVA版）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

public static void main(String[] args){
        String s1 = "abc";
        List<String> list = new ArrayList<>();
        list.add(s1);
        s1 = s1.concat("d");
        System.out.println(list.get(0));		//abd
        String s2 = s1.concat("e");
        list.set(0, s2);
        System.out.println(list.get(0));		//abcde
    }

1
2
3

final int a = 5;

a = 10; (×)

1

return new Date(groundhogAnswer.getTime());

1
2
3

public interface Set<E>{...}
public class CharSet implements Set<Character>{...}
public class HashSet implements Set<E>{...}

1
2
3

List<?> list = new ArrayList<String>();
List<? extends Animal>
List<? super Animal>

1
2
3
4
5

Integer a = new Integer(3);
Integer b = new Integer(3);
System.out.println(a==b);    // false
System.out.println(a.equals(b));	//true
System.out.println((int)a==(int b));	//true

1
2
3
4
5

Map<String, Integer> a = new HashMap(),b = new HashMap();
a.put("c",130)
b.put("c",130)
System.out.println(a.get("c")==b.get("c"));    // false
System.out.println(a.get("c").equals(b.get("c")));	//true

1
2
3
4
5

Map<String, Integer> a = new HashMap(),b = new HashMap();
a.put("c",1)
b.put("c",1)
System.out.println(a.get("c")==b.get("c"));    // true
System.out.println(a.get("c").equals(b.get("c")));	//true

1
2
3
4
5
6
7
8
9

// numbers是引用，类型为Number[]
Number[] numbers = new Number[2];
numbers[0] = new Integer(10);
numbers[1] = new Double(3.14); //不会报错

// myNumber是对象，与myInts类型相同，在运行时Java知道myNumber实际上是Integer[]
Integer[] myInts = {1,2,3,4};
Number[] myNumber = myInts;
myNumber[0] = 3.14; 	//run-time error!

1
2
3
4
5

List<Integer> myInts = new ArrayList<Integer>();
myInts.add(1);
myInts.add(2);
List<Number> myNums = myInts;	//compiler error！
myNums.add(3.14);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

public class EdgeComparator	implements Comparator<Edge>{
@Override
public int compare(Edge o1, Edge o2) {
	if(o1.getWeight() > o2.getWeight())
	return 1;
	else if (.. == ..) return 0;
	else return -1;
	}
}

// 实现后需要新建一个Comparator
public void sort(List<Edge> edges) {
	Comparator comparator = new EdgeComparator();
	Collections.sort(edges, comparator);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

public class Edge implements Comparable<Edge> {
	Vertex s, t;
	double weight;
	...
	public int compareTo(Edge o) {
		if(this.getWeight() > o.getWeight())
			return 1;
		else if (.. == ..) return 0;
		else return -1;
	}
}

//	不需要构建新的Comparator类，比较代码放在ADT内部
public void sort(List<Edge> edges) {
	Collections.sort(edges);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

class LegacyRectangle {
	void display(int x1, int y1, int w, int h) {... }
}

// 接口不匹配
class Client {
	public display() {
		new LegacyRectangle().display(x1, y1, x2, y2);
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

interface Shape {
	void display(int x1, int y1, int x2, int y2);
}
// Adaptor
class Rectangle implements Shape {
	void display(int x1, int y1, int x2, int y2) {
		new LegacyRectangle().display(x1, y1, x2-x1, y2-y1);
	}
}

class LegacyRectangle {
	void display(int x1, int y1, int w, int h) {...}
}
class Client {
    // 适配
	Shape shape = new Rectangle();
	public display() {
		shape.display(x1, y1, x2, y2);
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

// 包装stack得到Decorator基本类
public abstract class StackDecorator implements Stack {
	protected final Stack stack;
	public StackDecorator(Stack stack) {
		this.stack = stack;
	}
	public void push(Item e) {
		stack.push(e);
	}
	public Item pop() {
		return stack.pop();
	}
	...
}

// 对其进行包装
public class UndoStack extends StackDecorator implements Stack {
	private final UndoLog log = new UndoLog();
	public UndoStack(Stack stack) {
		super(stack);
	}
	public void push(Item e) {
		log.append(UndoLog.PUSH, e); //新特性
		super.push(e);
	}
	public void undo() {
		//implement decorator behaviors on stack
	}
	...
}

//使用
Stack t = new UndoStack(new ArrayStack());

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

// 抽象父类
public abstract class OrderProcessTemplate{
    public boolean isGift;
	public abstract void doSelect();
	public abstract void doPayment();
    // 相同的步骤操作在抽象父类中直接实现
	public final void giftWrap() {
		System.out.println("Gift wrap done.");
	}
	public abstract void doDelivery();
    // 步骤模板
	public final void processOrder() {
		doSelect();
		doPayment();
		if (isGift)
			giftWrap();
		doDelivery();
	}
}
// 子类重写父类的非公共操作
public class NetOrder extends OrderProcessTemplate {
	@Override
	public void doSelect() { … }
	@Override
	public void doPayment() { … }
	@Override
	public void doDelivery() { … }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

// 接口
public interface Iterator {
	public Object next(); 
	public boolean hasNext();
}
// 实现Interator
public class ConcreteIterator implements Iterator {

    private List list = new ArrayList();
    private int cursor = 0;

    public ConcreteIterator(List list) {
        this.list = list;
    }

    @Override
    public Object next() {
        Object obj = null;
        if (this.hasNext()) {
            obj = this.list.get(cursor++);
        }
        return obj;
    }

    @Override
    public boolean hasNext() {
        if (cursor == list.size()) {
            return false;
        }
        return true;
    }
}
// 抽象容器
public interface Aggregate {
    public void add(Object obj);  
    public void remove(Object obj);  
    public Iterator iterator(); 
}
// 在容器中添加Iterator获取
public class ConcreteAggregate implements Aggregate {

    private List list = new ArrayList();  
    
    @Override
    public void add(Object obj) {
        list.add(obj);
    }
    @Override
    public void remove(Object obj) {
        list.remove(obj);
    }
    @Override
    public Iterator iterator() {
         return new ConcreteIterator(list); 
    }
}
// 客户端使用
public class Client {
    public static void main(String[] args) {
        Aggregate ag = new ConcreteAggregate();
        ag.add("小明");
        ag.add("小红");
        ag.add("小刚");
        Iterator it = ag.iterator();
        while (it.hasNext()) {
            String str = (String) it.next();
            System.out.println(str);
        }
      }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

// 两个责任：Connection Management 、Data Communication
interface Modem {
	public void dial(String pno);
	public void hangup();
    
	public void send(char c);
	public char recv();
}

// 应该分开
interface DataChannel {
	public void send(char c);
	public char recv();
}
interface Connection {
	public void dial(String phn);
	public char hangup();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

public void drawShape(Shape s) {
	if (s.m_type==1)		// if-else将导致扩展新行为时改变原有代码
		drawRectangle(s);
	else if (s.m_type==2)
	drawCircle(s);
}
	public void drawCircle(Circle r)
	{....}
	public void drawRectangle(Rectangle r)
	{....}
}

class Shape {
	int m_type;
}
class Rectangle extends Shape {
	Rectangle() {
		super.m_type=1;
	}
}
class Circle extends Shape {
	Circle() {
		super.m_type=2;
    }
}

// 将不同功能封装到不同形状中可以实现OCP
class GraphicEditor {
	public void drawShape(Shape s) {
		s.draw();
	}
}
class Shape {
	abstract void draw();
}
class Rectangle extends Shape {
	public void draw() {
	// draw the rectangle
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

//文学经典类
public class LiteraryClassic{
    //阅读文学经典
    public void read(){
       System.out.println("文学经典阅读，滋润自己的内心心灵");
    }
}
//小明类
public class XiaoMing{
    //阅读文学经典
    public void read(LiteraryClassic literaryClassic){
        literaryClassic.read();
    }
}
// 场景
public class Client{
   public static void main(Strings[] args){
      XiaoMing xiaoming = new XiaoMing();
      LiteraryClassic literaryClassic = new LiteraryClassic();
      //小明阅读文学经典
      xiaoming.read(literaryClassic);
   }
}

//但小明想看小说时，发现中委托实现依赖LiteraryClassic具体类
//小说类
public class Novel{
    //阅读小说
    public void read(){
       System.out.println("阅读小说，放松自己");
    }
}
//正确的做法应该是创建小说与文学经典的父类Book，小明委托Book中的read

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

// 产品接口
public interface Trace { // turn on and off debugging
	public void setDebug( boolean debug );
	// write out a debug message
	public void debug( String message );
    // write out an error message
	public void error( String message );
}
// 具体实现类1
public class FileTrace implements Trace {
    ...
}
// 具体实现类2
public class SystemTrace implements Trace {
    ...
}
// Client使用只能绑定到具体的类
Trace log = new SystemTrace();
log.debug( "entering log" );
Trace log2 = new FileTrace();
log.debug(“...”);

// 如果使用工厂方法
interface TraceFactory {
	public Trace getTrace();
	public Trace getTrace(String type);
	void otherOperation(){};
}
public class Factory implements TraceFactory {
	public Trace getTrace() {
		return new SystemTrace();
	}    
    public getTrace(String type) {
		if(type.equals(“file”)
			return new FileTrace();
		else if (type.equals(“system”)
			return new SystemTrace();
    }
}
              
// 客户端无需绑定到具体类
Trace log1 = new Factory1().getTrace();
log1.setDebug(true);
log1.debug( "entering log" );
Trace log2 = new Factory2().getTrace("system");
log2.setDebug(false);
log2.debug("...");

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

// 抽象工厂
public interface AbstractWidgetFactory{
	public Window createWindow();
	public Scrollbar createScrollbar();
}
// 具体工厂1
public class WidgetFactory1 implements AbstractWidgetFactory{
	public Window createWindow(){
		...
	}
	public Scrollbar createScrollbar(){...}
}
// 具体工厂2
public class WidgetFactory2 implements AbstractWidgetFactory{
	public Window createWindow(){
		...
	}
	public Scrollbar createScrollbar(){...}
}
// 辅助类用来确定顺序
public class GUIBuilder{
	public void buildWindow(AbstractWidgetFactory widgetFactory){
        //先创建window
		Window window = widgetFactory.createWindow();
        //再创建scrollbar
		Scrollbar scrollbar = widgetFactory.createScrollbar();
		window.setTitle("New Window");
		window.addScrollbar(scrollbar);
	}
}
// Client
GUIBuilder builder = new GUIBuilder();
AbstractWidgetFactory widgetFactory = null;
if(“Motif”)
	widgetFactory = new WidgetFactory2();
else
	widgetFactory = new WidgetFactory1();
// 利用辅助类创建
builder.buildWindow(widgetFactory);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

public interface Image {
	void display();
}
public class RealImage implements Image {
	private String fileName;
	public RealImage(String fileName){
		this.fileName = fileName;
		loadFromDisk(fileName);
	}
	@Override
	public void display() {…}
	private void loadFromDisk(String fileName){…}
}
// 隐藏RealImage类
public class ProxyImage implements Image {
	private Image realImage;
	private String fileName;
	public ProxyImage(String fileName){
		this.fileName = fileName;
	}
	@Override
	public void display() {
		if(realImage == null){
		realImage = new RealImage(fileName);
	}
	realImage.display();
	}
}
//Client:
Image image = new ProxyImage(“pic.jpg");
image.display();
image.display();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

// 广播者，偶像
public class Subject {
    // 粉丝
	private List<Observer> observers = new ArrayList<Observer>();
	private int state;
	public int getState() {return state;}
	public void setState(int state) {
		this.state = state;
		notifyAllObservers();
	}
    // 绑定粉丝
	public void attach(Observer observer){observers.add(observer);}
	private void notifyAllObservers(){ // 一对多广播
		for (Observer observer : observers) {
			// 通过委托实现
            observer.update();
		}
	}
}
// 接受广播者， 粉丝
public abstract class Observer {
	protected Subject subject;
	public abstract void update();
}
// 具体粉丝
public class BinaryObserver extends Observer{
    // 通过偶像创建
	public BinaryObserver(Subject subject){
		this.subject = subject;
		this.subject.attach(this);
	}
	@Override
	public void update() {
		System.out.println( "Binary String:"+Integer.toBinaryString(subject.getState()));
	}
}

// Client
Subject subject = new Subject();
new HexaObserver(subject);
new OctalObserver(subject);
new BinaryObserver(subject);
attach...
System.out.println("First state change: 15");
subject.setState(15);
System.out.println("Second state change: 10");
subject.setState(10);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

// 数据结构
public interface ItemElement {
	public int accept(ShoppingCartVisitor visitor);
}
// 具体数据结构1
public class Book implements ItemElement{
	private double price;
	...
	int accept(ShoppingCartVisitor visitor) {
		// 委托ShoppingCartVisitor类
        visitor.visit(this);
	}
}
// 具体数据结构2
public class Fruit implements ItemElement{
	private double weight;
	...
	int accept(ShoppingCartVisitor visitor) {
        // 委托ShoppingCartVisitor类
		visitor.visit(this);
	}
}
// visitor抽象类
public interface ShoppingCartVisitor {
	int visit(Book book);
	int visit(Fruit fruit);
}
// visitor实现类，实现操作与数据结构的分离
public class ShoppingCartVisitorImpl implements ShoppingCartVisitor {
	public int visit(Book book) {
        // 操作细节
		int cost=0;
		if(book.getPrice() > 50){
			cost = book.getPrice()-5;
		}else
		cost = book.getPrice();
		System.out.println("Book ISBN::"+book.getIsbnNumber() + " cost ="+cost);
		return cost;
	}
	public int visit(Fruit fruit) {
		int cost = fruit.getPricePerKg()*fruit.getWeight();
		System.out.println(fruit.getName() + " cost = "+cost);
		return cost;
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

// 
class Memento {
    private State state; 
	public Memento(State state) {
		this.state = state;
	}
	public State getState() {
		return state;
	}
}

class Originator {
	private State state;
	public void setState(State state) {
		System.out.println("Originator: Setting state to " + state.toString());
		this.state = state;
	}
	public Memento save() {
		System.out.println("Originator: Saving to Memento.");
		return new Memento(state);
	}
    // 恢复历史记录
	public void restore(Memento m) {
		state = m.getState();
		System.out.println("Originator: State after restoring from Memento: " + state);
	}
}

class Caretaker {
	private List<Memento> mementos	= new ArrayList<>();
	public void addMemento(Memento m) {
		mementos.add(m);
	}
	public Memento getMemento() {
		return mementos.get(?);  //具体需要回滚到那个版本
	}
}
// Client
public static void main(String[] args) {
	Caretaker caretaker = new Caretaker();
	Originator originator = new Originator();
	originator.setState("State1");
	originator.setState("State2");
    // 存档
	caretaker.addMemento( originator.save() );
	originator.setState("State3");
    // 存档
	caretaker.addMemento( originator.save() );
	originator.setState("State4");
    // 恢复
	originator.restore( caretaker.getMemento() );
}

1
2
3
4
5
6
7

root = (A B)+
A = [Aa] // 字符A与a
B = [Bb] 
    //aaaBBB ×
	//abababab √
	//aBAbabAB √
	//AbAbAbA ×

1
2
3
4
5
6
7

try {
	access the database...
}
catch (SQLException e) {
    // rethrow
	throw new ServletException("database error: " + e.getMessage());
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

try{
	...
	return true;
}finally{
    ...		//不管怎么样都会执行到finally，都会返回false
    return false;
}

int a=1;
try{
	...
	return true;
}finally{
    ...		//不管怎么样都会执行到finally，方法返回true，但是a会变为2
    a=2;
}

1
2
3
4
5
6

try (Scanner in = new Scanner(new FileInputStream("/dict/words")),"UTF-8") {
	while (in.hasNext())
	System.out.println(in.next());
}catch(){
    ...
}//结束后会自动调用in.close()

1
2
3
4
5
6
7
8

public class FooException extends Exception {
	public FooException() { super(); }
	public FooException(String message) { super(message); }
	public FooException(String message, Throwable cause) {
		super(message, cause);
	}
	public FooException(Throwable cause) { super(cause); }
}

1
2
3

//两种格式
assert (something_should_be_true);
assert (something_should_be_true):"print something you want"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

/**
* Reverses the end of a string.
*
* 012345 012345
* For example: reverseEnd("Hello, world", 5) returns "Hellodlrow ,"
* <-----> <----->
*
* With start == 0, reverses the entire text.
* With start == text.length(), reverses nothing.
*
* @param text non-null String that will have its end reversed
* @param start the index at which the remainder of the input is reversed,
* requires 0 <= start <= text.length()
* @return input text with the substring from start to the end of the string
* reversed
*/
public static String reverseEnd(String text, int start)
   //等价类划分
   //对于start参数：start = 0, 0 < start < text.length(), start = text.length()
   //对于text参数：text.length() = 0; text.length()-start is odd; text.length()-start is even

1
2
3
4
5
6
7

 max(int a,int b) : int × int → int
     //等价类划分
     // a,b间的关系：a>b;a<b;a==b
     //	a的值：a<0;a=0;a>0;a是最小整数、a是最大整数
     // b的值：b<0;b=0;b>0;b是最小整数、b是最大整数
     //  笛卡尔积测试：3*5*5个测试用例
     //	 非笛卡尔积测试：3+5+5个测试用例以内

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

public class HelloThread extends Thread {
	// 只需重写run方法
    public void run() {
		System.out.println("Hello from a thread!");
	}
    
    //启动该线程的两个方式
	public static void main(String args[]) {
		HelloThread p = new HelloThread();
		p.start();
	}
	
	public static void main(String args[]) {
		(new HelloThread()).start();
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

public class HelloRunnable implements Runnable {
	public void run() {
		System.out.println("Hello from a thread!");
	}
    
	public static void main(String args[]) {
        // 启动线程
		(new Thread(new HelloRunnable())).start();
	}
}

// 也可简写
new Thread(new Runnable() {
	public void run() {
		System.out.println("Hello");
	}
}).start();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

private static int x = 1;
public static void methodA() {
	x *= 2;
	x *= 3;
}
public static void methodB() {
	x *= 5;
}
//	x *= 2的原子操作为：
//		1.取出x放入寄存器
//		2.寄存器值*2
//		3.将寄存器的值写回x
//
// 并行运行A、B，最终x可能为5，6，10，30
//	5：B取出x=1 ---> A方法执行结束 ---> B寄存器值*5 ---> 写回x=5
//	6: A执行x*=2后x=2 ---> A取出x=2 ---> B方法执行结束 ---> A寄存器值*3 ---> 写回x=6
//	10: A执行x*=2后x=2 ---> B取出X=2 ---> A方法执行x*=3 ---> B寄存器值*5 ---> 写回x=10
//	30: 顺序执行即可

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

class Task implements Runnable{
	private double d = 0.0;
	public void run() {
		try{
			while (true) {
                // 正常运行时就算接收到中断信号也不理会，继续执行
				for (int i = 0; i < 900000; i++)
					d = d + (Math.PI + Math.E) / d;
                // 直到sleep()时才会检测是否收到中断信号，如果收到则自动抛出中断异常
				Thread.sleep(500);
                // 或者直接用Thread.interrupted或者isInterrupted检测
                //if (Thread.interrupted()) {
				//	throw new InterruptedException();
				//}
			}
          	//进入异常处理执行return后，线程才真正终止
		} catch(InterruptedException e) {return;}
	}
}

Thread t = new Thread(new Task());
t.start();
Thread.sleep(100); //当前线程休眠
t.interrupt(); //试图中断t线程

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

public class JoinExample2 {
    // 三个进程操作之间的执行次序并不确定
	public static void main(String[] args) {
		Thread th1 = new Thread(new MyClass2(), "th1");
		Thread th2 = new Thread(new MyClass2(), "th2");
		Thread th3 = new Thread(new MyClass2(), "th3");
		th1.start();
		th2.start();
		th3.start();
		}
}

// 三个进程操作执行次序确定，th1所有操作顺序执行结束 --> th2... --> th3...
public class JoinExample {
	public static void main(String[] args) {
		Thread th1 = new Thread(new MyClass(), "th1");
		Thread th2 = new Thread(new MyClass(), "th2");
		Thread th3 = new Thread(new MyClass(), "th3");
        
		th1.start();
		try {
            // main进程不会继续执行，直到th1执行结束
            // join过程中也会接受中断信号并自动抛出异常
			th1.join();
		} catch (InterruptedException ie) {}
        
		th2.start();
		try {
			th2.join();
		} catch (InterruptedException ie) {}
        
		th3.start();
		try {
			th3.join();
		} catch (InterruptedException ie) {}
	}
}

1

private static Map<Integer,Boolean> cache =Collections.synchronizedMap(new HashMap<>());

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

方法A:
if ( ! lst.isEmpty()) {
	String s = lst.get(0);
	...
}
方法B:
 //释放lst

//A与B并行时，A方法中判断lst非空后，B方法将其释放，在A方法get(0)就会访问空指针报错
//虽然lst是threadsafe的，但多个操作之间仍然不可靠，

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

Object lock = new Object();

//方法A:
synchronized (lock) { // thread blocks here until lock is free
	// now this thread has the lock
	balance = balance + 1;
	// exiting the block releases the lock
}

//方法B:
synchronized (lock) {
    ...
}
// 类似于在lock对象的锁位上置1
// 如果先执行方法A的锁，方法B检测到lock已经被置1便无法执行，直到A执行结束，锁释放

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

//Thread A
public void run() {
	…
	synchronized(lst) {
	… }
}

//Thread B
public void run() {
	…
	lst.add(…);
	lst.size();
}

// A、B线程可以并行

1
2
3
4
5

// 如果进入到A，把a锁上的同时进入到B，把b锁上
// 这样方法A等待B释放b，方法B等待A释放a
// 就会造成死锁
Method A: synchronized(a){ synchronized(b){ … } }
Method B: synchronized(b){ synchronized(a){ … } }