分享未来 ^Internet _Technology

在阅读java核心技术第一卷时有一个技术细节值得记录一下：

基本数据类型数组和Object类型是可以互相转换的，但是基本数据类型不能和Object[]对象型数组进行转换。

简言之： 在java中数组是对象，对象数组和原始数据类型数组在使用方法上几乎是完全一致的，唯一的差别在于对象数组容纳的是引用而原始数据类型数组容纳的是具体的数值。

比如如下代码：

[code="java"]

import java.util.Arrays;



public class test {
private static void r(Object o){
System.out.println(Arrays.toString((int[])o));
}
/**
* @param args
*/
public static void main(String[] args) {
int[] a = new int[10];
r(a);


}

}
[/code]

我们可以看到输出结果为：

[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

但我们不能将静态方法r中的参数类型申明为Object[] ，这样是编译不通过的。

在非基本类型数组与Object之间的转换时我们可以使用Object做为参数类型，也可以使用Object[]做为参数类型，其中的区别可以参考如下代码:

[code="java"]

class Student{
String name="zhang";

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}
}


public class test {
private static void r1(Object o){
for(Object obj : (Object[])o){
System.out.println(((Student)obj).getName());
}
}

private static void r2(Object[] o){
for(Object obj : o){
System.out.println(((Student)obj).getName());
}
}

public static void main(String[] args) {
Student[] student = {new Student(),new Student()};
r1(student);
r2(student);
}

}
[/code]

输出结果是一样的。

直接贴上学习的测试代码：

[code="java"]
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

class func {
private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
private Lock wl = rwl.writeLock();
private Lock rl = rwl.readLock();

public void ww() throws InterruptedException {
wl.lock();
Thread.sleep(2000);
System.out.println("write here");
wl.unlock();
}

public void rr() throws InterruptedException {
rl.lock();
Thread.sleep(3000);
System.out.println("read here");
rl.unlock();
}
}

public class test {

public static void main(String[] args) {

final func f = new func();

Thread thread1 = new Thread(new Runnable() {

@Override
public void run() {

try {
f.rr();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
Thread thread2 = new Thread(new Runnable() {

@Override
public void run() {
try {
f.rr();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});

Thread thread3 = new Thread(new Runnable() {

@Override
public void run() {
try {
f.ww();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});

thread1.start();
thread2.start();
thread3.start();
}

}
[/code]

从运行的代码结果可以看出，线程在执行读锁的时候互相不会阻塞，但是读锁和写锁之间会相互被阻塞，同时读锁和读锁之间也是会相互阻塞的。

简单点说就是：A君在写文章，B君和C君只能等待，等A写完了B和C才能看，如果B和C都在看文章，A君就必须等待他们看完才能继续写文章。

在java中synchronized同步关键字可以使用在静态方法和实例方法中使用，两者的区别在于：

静态锁：  在静态方法前面加上synchronized方法表示锁定此类，当多个线程调用这个类中的静态方法时会阻塞。

实例锁： 在实例方法前面加上synchronized方法表示锁定类的单个实例，当多个线程调用一个类申明的同一个实例的实例方法是会阻塞。

例如一个类func中有如下方法静态方法：

[code="java"]
class func{
public synchronized static void staticFuncA() throws InterruptedException{
TimeUnit.SECONDS.sleep(2);
System.out.println("This thread is "+Thread.currentThread().getName());
}

public synchronized static void staticFuncB() throws InterruptedException{
TimeUnit.SECONDS.sleep(2);
System.out.println("static func b");

}

public static void staticFunC(){
System.out.println("static fun c");
}


public synchronized void funcD() throws InterruptedException{
Thread.sleep(2000);
System.out.println("func d");
}

public synchronized void funcE() throws InterruptedException{
Thread.sleep(2000);
System.out.println("func e");
}

}
[/code]

当多个线程都需要执行staticFuncA或staticFuncB方法时，当某一个线程抢占到静态锁的方法，其他线程都会在调用静态锁方法时被阻塞并等待抢占到静态锁方法的线程执行完毕。而不具有静态锁特性的静态方法staticFunC就不受锁的影响，可以随意执行而不会被阻塞。总结： 静态锁是对全局带有synchronized的静态方法产生影响。

而在实例锁中，实例方法的同步是在多个线程调用同一个对象时受到锁的控制，并且和静态方法一样，同样会影响到所有非静态具有synchronized的方法。但静态锁和实例锁两者间的同步并不会受到互相干扰，也就是说线程调用staticFunB并不会影响到其他线程调用funcE。

表单元素的两个事件：