java线程详解（二）

1，线程安全

先看上一节程序，我们稍微改动一下：

//线程安全演示
//火车站有16张票，需要从四个窗口卖出，如果按照上面的多线程实现，程序如下
class Ticket implements Runnable   
{
    private int tick = 16;//票的张数---16
    public void run(){   
        while(true){
            if(tick>0){
                //这里的sleep(100)是这次程序要表的关键，只是个模拟而已
                try{
                    Thread.sleep(100);
                }catch(Exception e){
                    
                }
              System.out.println(Thread.currentThread().getName() + "...sale:" + tick--);    
            }
        }
        
    }
    public static void main(String[] args)
    {
        Ticket t = new Ticket();

        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);
        Thread t3 = new Thread(t);
        Thread t4 = new Thread(t);

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

其他之处没有改变，只是在判断还有票之后立即睡眠一段时间，这在现实中有可能发生的，线程A刚执行到这里，突然cpu切换到其他线程B中，而B线程也刚好执行到判断语句又被A线程抢夺cpu，此时A线程不用再判断，直接输出，并修改ticket的值，此时有可能使得tickte>0不再满足，但是下一次B线程执行时，也不去判断tickte的值，导致出错。看看上面的程序结果（不为一），数了一下，打印了20张票，还有-1，-2，0的 情况，这就是线程安全问题了。

问题原因：当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完另一个线程就来执行，导致共享数据的错误。

解决办法：对多条操作共享数据的语句，只能让一个线程都执行过程中，其他线程也不能执行。即使其他线程拿到执行权！这就是java提供的同步代码块方案。其格式如下：

synchronized(对象){

需要同步的代码块

}

分析：上面的synchronized后面的对象如同锁，也叫同步监视器，持有锁的线程可以同步执行，没有持有锁的线程即使获取cpu的执行权，也不能进不去同步代码块。线程开始执行同步代码块必须先对同步监视器的锁定。

同步前提：

（1）必须有两个或者两个以上的线程。

（2）必须是多个线程使用同一个锁。

任何时刻只有一个线程获得对同步监视器的锁定，当同步代码块执行结束时，该线程会释放对同步监视器的锁定。

如何看哪些代码需要同步？看看共享数据参与运算的范围。if(tick>0)，还有tick—；因此把上面程序改为如下：

//线程安全演示
//火车站有16张票，需要从四个窗口卖出，如果按照上面的多线程实现，程序如下
class Ticket implements Runnable   
{
    private int tick = 16;//票的张数---16
    Object obj = new Object();
    public void run(){   
        while(true){
            synchronized(obj){
                if(tick>0){
                    //这里的sleep(100)是这次程序要表的关键，只是个模拟而已
                    try{
                        Thread.sleep(10);
                    }catch(Exception e){
                        
                    }
                  System.out.println(Thread.currentThread().getName() + "...sale:" + tick--);    
                }
            }
        }
        
    }
    public static void main(String[] args)
    {
        Ticket t = new Ticket();

        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);
        Thread t3 = new Thread(t);
        Thread t4 = new Thread(t);

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

此时运行就没有出现错误。结果就不展示了。

好处：解决线程安全问题

缺点：多线程需要判断锁，较为消耗资源

2，线程同步

再看下面的例子

/*
需求：银行有一个金库，有两个储户分别存入300元，都是分3次存入
目的：查看该程序是否有安全问题，如果有，如何解决？
如何找问题：
1，明确哪些代码是多线程运行代码
2，明确哪些是共享数据
3，明确哪些代码使用共享数据
*/

class Bank
{
    //Object obj = new Object();  ------1
    private int sum;
    public synchronized void add(int n){ //synchronized可以放在此处作为同步函数
        //synchronized(obj){  ------2
            sum = sum + n;
            try{
                Thread.sleep(10);
            }catch(Exception e){
                        
            }
            System.out.println("sum = " + sum);
        //} ------3
    }
}

class Cus implements Runnable
{
    private Bank b = new Bank();
    public void run(){
        for(int x = 0; x < 3; x++){
            b.add(100);
        }
    }
}

class BankDemo
{
    public static void main(String[] agrs){
        Cus c = new Cus();
        Thread t1 = new Thread(c);
        Thread t2 = new Thread(c);
        t1.start();
        t2.start();
    }

}

上面代码如果不同步就会出现线程安全问题，但是同步不止刚才那种同步代码块，还有同步函数可以使用，本程序就是个例子。但是对于卖票那个程序来试试

//线程安全演示
//火车站有16张票，需要从四个窗口卖出，如果按照上面的多线程实现，程序如下
class Ticket implements Runnable   
{
    private int tick = 160;//票的张数---160
    //Object obj = new Object();
    public synchronized void run(){   
        while(true){
            //synchronized(obj){
                if(tick>0){
                    //这里的sleep(1000)是这次程序要表的关键，只是个模拟而已
                    try{
                        Thread.sleep(100);
                    }catch(Exception e){
                        
                    }
                  System.out.println(Thread.currentThread().getName() + "...sale:" + tick--);    
                }
            //}
        }
        
    }
    public static void main(String[] args)
    {
        Ticket t = new Ticket();

        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);
        Thread t3 = new Thread(t);
        Thread t4 = new Thread(t);

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

结果

其实这里面一直是线程0在执行，因为run方法是在同步，当0线程执行时别的线程都不能执行，这是因为同步的代码块范围不正确，只需要把需要同步的代码块封装为一个函数，便可以在run方法中调用这个函数即可。

//线程安全演示
//火车站有16张票，需要从四个窗口卖出，如果按照上面的多线程实现，程序如下
class Ticket implements Runnable   
{
    private int tick = 160;//票的张数
    public void run(){   
        while(true){
            show();//此处调用show方法
        }
        
    }

    public synchronized void show(){//将同步代码块封装起来
        if(tick>0){
            try{
                Thread.sleep(100);
            }catch(Exception e){
                        
            }
             System.out.println(Thread.currentThread().getName() + "...sale:" + tick--);    
        }
    }
    public static void main(String[] args)
    {
        Ticket t = new Ticket();

        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);
        Thread t3 = new Thread(t);
        Thread t4 = new Thread(t);

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

此时可以看到几个线程都启动了。那么有个疑问，同步代码块这种方法有个同步监视器来进行锁住。那么同步方法怎么实现呢？

其实函数都需要对象调用，每个函数都有一个对象引用，就是隐含的this，所以同步函数使用的锁就是this。

通过程序来验证：

使用两个线程来实现卖票，第一个线程在同步函数中，第二个线程在同步代码块中。都在执行卖票动作。

class Ticket implements Runnable   
{
    private int tick = 16;//票的张数
    Object obj = new Object();
    boolean flag = true;
    public  void run(){ 
        if(flag){
            while(true){
                synchronized(obj){
                    if(tick>0){
                        try{
                            Thread.sleep(100);
                        }catch(Exception e){
                        
                        }
                      System.out.println(Thread.currentThread().getName() + "...code:" + tick--);    
                    }
                }
            }
        }
        else{
            while(true){
                show();
            }
        }
    }

    public synchronized void show(){
        if(tick>0){
            try{
                Thread.sleep(100);
            }catch(Exception e){
                        
            }
             System.out.println(Thread.currentThread().getName() + "...show:" + tick--);    
        }
    }
    public static void main(String[] args)
    {
        Ticket t = new Ticket();

        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);

        t1.start();
        try{
            Thread.sleep(100);
        }catch(Exception e){
                        
        }
        t.flag = false;
        t2.start();

    }
}

结果如下

先来解释一下，这个程序的run()方法中有同步代码块，还有一个同步函数。我们的意思是想让t1先执行，在main函数中让其sleep是因为如果没有sleep的话，主线程可能没有分配给t1的cpu执行权直接执行下面的flag = false这句，导致同步代码块中的代码永远不能执行。加入sleep可以执行同步代码块的代码，也可以执行同步函数中的代码，但是看到结果，打印了0号票，这是不允许的，是什么造成了这种情况？

看看文章最前面的同步的前提，有两个，再次提出：

（1）必须有两个或者两个以上的线程。-----满足

（2）必须是多个线程使用同一个锁。-----不满足-----〉第一个锁是synchronized(obj)中的obj，还有一个同步函数，它的锁是this，就是调用它的对象。

把synchronized(obj)这句换为synchronized(this),就不会出现上述问题，所以这样满足第二个前提，说明同步函数使用的的确是this这个锁。

有个情况，如果同步函数使用static修饰，那么静态方法中的锁是谁呢？肯定不是this，因为静态方法没有this。静态进内存时没有本类对象，但是有本类的字节码对象，该对象的类型是class.因此，对于静态方法，他的同步监视器（也就是锁）就是类名.class。把synchronized(obj)这句换为synchronized(Ticket.class),就不会出现0号票了。

3，死锁

死锁原因：同步中嵌套同步，但是锁却不同步。

先修改上面的程序

class Ticket implements Runnable   
{
    private int tick = 1000;//票的张数
    Object obj = new Object();
    boolean flag = true;
    public  void run(){ 
        if(flag){
            while(true){
                synchronized(obj){
                    System.out.println("*****************");
                    show();
                }
            }
        }
        else{
            while(true){
                System.out.println("------------------");
                show();
            }
        }
    }

    public synchronized void show(){
        synchronized(obj){
            if(tick>0){
                try{Thread.sleep(10);}catch(Exception e){}
                 System.out.println(Thread.currentThread().getName() + "...code:" + tick--);    
            }
        }
    }
    public static void main(String[] args)
    {
        Ticket t = new Ticket();
        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);
        t1.start();
        try{Thread.sleep(100);}catch(Exception e){}
        t.flag = false;
        t2.start();

    }
}

上面的程序出现死锁，原因是同步代码块中锁是obj，且嵌套同步函数（其锁是this），同步函数的锁是this，而其中又嵌套同步代码块，其锁是obj。可以修改锁即可。比如把obj全部换为this。这样代码就不会出错。但上述代码的输出-----和***之前加入一句判断语句if(tick>0)不然票卖完了还在打印。

上面的例子是同步代码块中包含同步函数，同步函数中又包含同步代码块，下面再看一个只在同步代码块中出现的死锁的例子。

class Test implements Runnable
{
    private boolean flag;
    Test(boolean flag){
        this.flag = flag;
    }
    public void run(){
        if(flag){
            synchronized(MyLock.locka){
                System.out.println("if a");
                synchronized(MyLock.lockb){
                    System.out.println("if b");
                }
            }
        }

        else{
            synchronized(MyLock.lockb){
                System.out.println("else b");
                synchronized(MyLock.locka){
                    System.out.println("else a");
                }
            }
        }
    }
}

class MyLock
{
    static Object locka = new Object();
    static Object lockb = new Object();
}

class DeadLockTest
{
    public static void main(String[] agrs){

        Thread t1 = new Thread(new Test(true)); 
        Thread t2 = new Thread(new Test(false));
        t1.start();
        t2.start();
    }
}

结合代码，在run()方法中，if语句中的同步代码块有嵌套，else也一样。他们也是这种情况：同步中嵌套同步，但是锁却不同步。

所以在以后的编程过程中一定要防止此类情况的发生。

注：这些代码和相关结论参见毕向东的java基础视频教程和李刚的《疯狂java讲义》，都非常不错！