5.txt

一些java的小代码

/** This class demonstrates how you might use the Rect class */ 
public class RectTest { 
public static void main(String[] args) { 
Rect r1 = new Rect(1, 1, 4, 4); // Create Rect objects 
Rect r2 = new Rect(2, 3, 5, 6); 
Rect u = r1.union(r2); // Invoke Rect methods 
Rect i = r2.intersection(r1); 

if (u.isInside(r2.x1, r2.y1)) // Use Rect fields and invoke a method 
System.out.println("(" + r2.x1 + "," + r2.y1 + 
") is inside the union"); 

// These lines implicitly call the Rect.toString() method 
System.out.println(r1 + " union " + r2 + " = " + u); 
System.out.println(r1 + " intersect " + r2 + " = " + i); 
} 
} 

****************************************************************** 
关于死锁的。 
/** 
* This is a demonstration of how NOT to write multi-threaded programs. 
* It is a program that purposely causes deadlock between two threads that 
* are both trying to acquire locks for the same two resources. 
* To avoid this sort of deadlock when locking multiple resources, all threads 
* should always acquire their locks in the same order. 
**/ 
public class Deadlock { 
public static void main(String[] args) { 
// These are the two resource objects we'll try to get locks for 
final Object resource1 = "resource1"; 
final Object resource2 = "resource2"; 
// Here's the first thread. It tries to lock resource1 then resource2 
Thread t1 = new Thread() { 
public void run() { 
// Lock resource 1 
synchronized(resource1) { 
System.out.println("Thread 1: locked resource 1"); 

// Pause for a bit, simulating some file I/O or 
// something. Basically, we just want to give the 
// other thread a chance to run. Threads and deadlock 
// are asynchronous things, but we're trying to force 
// deadlock to happen here... 
try { Thread.sleep(50); } 
catch (InterruptedException e) {} 

// Now wait 'till we can get a lock on resource 2 
synchronized(resource2) { 
System.out.println("Thread 1: locked resource 2"); 
} 
} 
} 
}; 

// Here's the second thread. It tries to lock resource2 then resource1 
Thread t2 = new Thread() { 
public void run() { 
// This thread locks resource 2 right away 
synchronized(resource2) { 
System.out.println("Thread 2: locked resource 2"); 

// Then it pauses, just like the first thread. 
try { Thread.sleep(50); } 
catch (InterruptedException e) {} 

// Then it tries to lock resource1. But wait! Thread 
// 1 locked resource1, and won't release it 'till it 
// gets a lock on resource2. This thread holds the 
// lock on resource2, and won't release it 'till it 
// gets resource1. We're at an impasse. Neither 
// thread can run, and the program freezes up. 
synchronized(resource1) { 
System.out.println("Thread 2: locked resource 1"); 
} 
} 
} 
}; 

// Start the two threads. If all goes as planned, deadlock will occur, 
// and the program will never exit. 
t1.start(); 
t2.start(); 
} 
}