The document provides tips on Java concurrency. It discusses using synchronized, volatile and java.util.concurrent classes like AtomicInteger for thread-safe operations on shared resources like account balances. Synchronized uses locks for mutual exclusion but volatile only ensures visibility, so atomic classes use Compare-And-Swap (CAS) operations for thread-safe updates without blocking.

1. Java TIPS

2. 





4. String str1 = new String(“hoge”);
String str2 = “hoge”;
System.out.println(str1 == str2);
System.out.println(str1.equals(str2));
False
True

5. == equals
char[] value
str1 str1 int length
boolean equals(Object obj)
char[] value
str2 str2 int length
boolean equals(Object obj)
str1 == str2 str1 str2
char[] value
str1.equals(str2)

6. java.lang.String
public final class String implements java.io.Serializable, Comparable<String>, CharSequence{
private final char value[];
private final int count;
public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
if (anObject instanceof String) {
String anotherString = (String)anObject;
int n = count;
if (n == anotherString.count) {
char v1[] = value;
char v2[] = anotherString.value;
int i = offset;
int j = anotherString.offset;
while (n-- != 0) {
if (v1[i++] != v2[j++])
return false;
}
return true;
}
}
return false;
}

7. equals
True
False
Account equals
Account equals

8. public abstract class Account{
private char[] custmorCode = new char[4];
Account(char[] custmorCode){
this.custmorCode = custmorCode;
}
public char[] getCustmorCode(){
return this.custmorCode;
}
@Override public boolean equals(Object obj){
//
}
}

9. SavingAccount a1 = new SavingAccount(new char[]{‘0’,’1’,’2’,’3’});
SavingAccount a2 = new SavingAccount(new char[]{‘9’,’1’,’2’,’3’});
TimeDepositAccount a3 = new TimeDepositAccount(new char[]{‘0’,’1’,’2’,’3’});
TimeDepositAccount a4 = new TimeDepositAccount(new char[]{‘9’,’1’,’2’,’3’});
System.out.println(a1.equals(a3));
System.out.println(a2.equals(a4));
System.out.println(a1.equals(a2));
System.out.println(a2.equals(a3));
True
True
False
False

10. getClass instanceof
boolean equals(Object obj)
Object
ClassCastException
instanceof Class getClass()
→ true → true
→ false
→ true
→ false

11. public abstract class Account{
//
@Override public boolean equals(Object obj){
if(obj instanceof Account){
//if(getClass() == obj.getClass()){
char[] compareCode = ((Account)obj).getCustmorCode();
if(custmorCode.length != compareCode.length){
return false;
}
for(int i = 0; i<custmorCode.length; i++){
if(custmorCode[i] != compareCode[i]){
return false;
}
}
return true;
} else {
return false;
}
}
}

13. equals
java.lang.Object String
char[] value
equals Instanceof
getClass equals

15. CASE:

16. Inspector
Inspector
100ms

17. Inspector
Inspector
100ms

18. Inspector Account
 100ms
 100ms
 100ms
 100ms
 100ms CPU

19. Inspector
Inspector
Inspector

20. public class Account{
private byte[] lock = new byte[0];
private ArrayList<Inspector> targets = new ArrayList<Inspector>();
public int get(int amount){
synchronized(lock){
if(this.amount < amount){
return 0;
}
for(Inspector i : targets){
i.inspect();
}
this.amount = this.amount - amount;
return amount;
}
}
public void addInspector(Inspector insp){
this.targets.add(insp);
}
 addInspector
 Inspector

21. CPU
CPU

23. String
public class Main{
public static void main(String[] args){
String className = "RefrectionTest";
RefrectionTest rt = null;
try{
rt = (RefrectionTest)Class
.forName(className).newInstance();
} catch(Exception e) {
}
rt.dosth();
}
}
public class RefrectionTest{
public void dosth(){
System.out.println("Do Something");
}
}

24. String
public class Main{
public static void main(String[] args){
String className = "RefrectionTest";
RefrectionTest rt = null;
try{
rt = (RefrectionTest)Class.forName(className).newInstance();
} catch(Exception e) {
}
String methodName = "dosth";
Method method = null;
try{
method = (Method)Class.forName(className)
.getMethod(methodName,null);
} catch(Exception e) {
}
method.invoke(Class.forName(className).newInstance(),null);
}
}

26. import java.io.*;
public class Main{
public static void main(String[] args){
Account a1 = new Account("hoge",5000);
a1.get(100);
try{
ObjectOutputStream oos = new ObjectOutputStream(
new FileOutputStream("hoge.ser"));
oos.writeObject(a1);
oos.close();
} catch(Exception e) {}
System.out.println(a1);
Account ser = null;
try{
ObjectInputStream ois = new ObjectInputStream(
new FileInputStream("hoge.ser"));
ser = (Account)ois.readObject();
ois.close();
} catch(Exception e) {}
ser.get(100);
System.out.println(ser);
}
}
public class Account implements Serializable{ // }

29. 1 2
100 100
0
0
100
100

 1 2

30. synchronized
public class Account{
private int amount;
private byte[] lock = new byte[0];
Account(int amount){
this.amount = amount;
}
public int get(int amount){
synchronized(lock){
this.amount = this.amount - amount;
return amount;
}
}
public void put(int amount){
synchronized(lock){
this.amount = this.amount + amount;
}
}
}
 Synchonized:

31. synchronized
1 2
100 100
0
100
0
200
 2 1

32. volatile
public class Account{
private volatile int amount;
Account(int amount){
this.amount = amount;
}
public int getAmount(){
return this.amount;
}
}

 syncronized
 sysnronized

33. volatile
1 2
100
0
0
100
100
 1
 2

34. Java.util.concurrent
import java.util.concurrent.atomic.*;
public class Account{
private AtomicInteger amount;
Account(int amount){
this.amount = new AtomicInteger(amount);
}
public int get(int amount){
if(this.amount.get() < amount){
return 0;
}
do{
if(this.amount.get() < amount){
break;
}
} while(!this.amount.compareAndSet(this.amount.get(), this.amount.get() - amount));
return amount;
}
public void put(int amount){
do{
if(amount < this.amount.get()){
break;
}
} while(!this.amount.compareAndSet(this.amount.get(), this.amount.get() + amount));
}
public int getAmount(){
return amount.get();
}
}

35. AtomicInteger
public class AtomicInteger extends Number implements java.io.Serializable {
private volatile int value;
public AtomicInteger(int initialValue) {
value = initialValue;
}
public final int get() {
return value;
}
public final void set(int newValue) {
value = newValue;
}
public final int getAndSet(int newValue) {
for (;;) {
int current = get();
if (compareAndSet(current, newValue))
return current;
}
}
public final boolean compareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
}
 CAS
 CAS
 Int CAS

36. CAS Compare And Swap
1 2
100
0
0
100
CAS


 2 0 CAS
100

37. synchonize
volatile
JDK5.0 java.util.concurrent
Java