//整数到字节数组的转换

public static byte[] intToByte(int number) {

    int temp = number;

    byte[] b=new byte[4];

    for (int i=b.length-1;i>-1;i–){

        b[i] = new Integer(temp&0xff).byteValue(); //将最高位保存在最低位

        temp = temp >> 8; //向右移8位

 }

 return b;

}

//字节数组到整数的转换

public static int byteToInt(byte[] b) {

    int s = 0;

    for (int i = 0; i < 3; i++) {

if (b[i] >= 0){

            s = s + b[i];

}else {

            s = s + 256 + b[i];

s = s * 256;

}

    }

    if (b[3] >= 0) { //最后一个之所以不乘，是因为可能会溢出

s = s + b[3];

} else {

        s = s + 256 + b[3];

}

    return s;

}

//字符到字节转换

public static byte[] charToByte(char ch){

    int temp=(int)ch;

    byte[] b=new byte[2];

for (int i=b.length-1;i>-1;i–){

        b[i] = new Integer(temp&0xff).byteValue(); //将最高位保存在最低位

        temp = temp >> 8; //向右移8位

    }

    return b;

}

//字节到字符转换

public static char byteToChar(byte[] b){

    int s=0;

    if(b[0]>0) {

        s+=b[0];

} else {

        s+=256+b[0];

}

s*=256;

if(b[1]>0) {

 s+=b[1];

} else {

 s+=256+b[1];

}

char ch=(char)s;

return ch;

}

//浮点到字节转换

public static byte[] doubleToByte(double d){

 byte[] b=new byte[8];

 long l=Double.doubleToLongBits(d);

 for(int i=0;i<b.length;i++){

 b[i]=new Long(l).byteValue();

 l=l>>8;

 }

 return b;

}

//字节到浮点转换

public static double byteToDouble(byte[] b){

 long l;

 l=b[0];

 l&=0xff;

 l|=((long)b[1]<<8);

 l&=0xffff;

 l|=((long)b[2]<<16);

 l&=0xffffff;

 l|=((long)b[3]<<24);

 l&=0xffffffffl;

 l|=((long)b[4]<<32);

 l&=0xffffffffffl;

 l|=((long)b[5]<<40);

 l&=0xffffffffffffl;

 l|=((long)b[6]<<48);

 l|=((long)b[7]<<56);

 return Double.longBitsToDouble(l);

}

a. 死锁分析：

   假设A和B同时在吃意大利面，而吃意大利面的条件是左手使用汤勺，右手使用叉子。现在只有一副餐具，A拿到了汤勺，B拿到了叉子，A等待B放下叉子，B等待A放下汤勺。则形成了死锁。

b. 出现死锁的条件：

• 具有多个SharedResource参与者，相当于汤勺和叉子。
• 线程锁定了一个SharedResource之后，在未解锁的情况下去锁定另一个SharedResource参与者，相当于A在拥有了汤勺之后，又去拿叉子；B在拥有了叉子之后又去拿汤勺。
• 获取SharedResource参与者的顺序不固定，参与者顺序对等，相当于汤勺和叉子的顺序相同，没有先后关系。

c. 上述1、2、3三个条件只要破坏了其中一种，则就解决了死锁的问题。

2、提高多线程执行性能的两种方式：

减少 SharedResource参与者参与者的个数，从而减少synchronized使用数量，减少获取对象锁的操作时间

尽量缩短临界区范围，从而减少线程冲突时等待的时间。

3、自己设计线程锁

oid method() {
    lock(); //锁
    try {
        ..
    } finally {
        unlock(); //最后无论什么情况都要解锁
    }
}

4、原子操作

• 用synchronized定义的方法或者块都具有原子性，只能被一个线程使用
• long、double为非原子性，其他类型以及对象等引用都是具有原子性
• 在定义long、double类型变量时，使用volatile修饰，表示对这个字段变量的定义为不可分隔的

总结：

• 基本类型、引用类型为原子操作
• long、double为可以分割的
• 在多线程中使用其作为共享参与者使用时，要么在使用时的方法用synchronized定义，或者使用volatile声明