Java多线程—线程同步(单信号量互斥)

JDK中Thread.State类的几种状态

线程的生命周期

 

 

 

 

线程的安全问题(同步与互斥)

方法一:同步代码块

多个线程的同步监视器(锁)必须的是同一把,任何一个类的对象都可以

      synchronized(同步监视器){

      }  //说明:操作共享数据的代码，即为需要被同步的代码(对共享数据的操作)

对于Thread实现和Runnable实现，同步锁需要区别

1.Thread下的同同步锁

class WinThread extends Thread{
/*
    方式一 继承Thread
*/
    private static int ticket=100;  //需要设置静态变量
    private static Object ticketLock=new Object(); //同步监视器，静态，因为要是共享唯一变量
    @Override
    public void run() {
        while(true)
        {
            synchronized (ticketLock){
                if (ticket > 0)
                {
                    System.out.println(this.getName() + "卖票: " + ticket);
                    ticket--;
                }
                else break;
            }

        }
    }
}

2.Runnable下的同步锁

class winRunnable implements Runnable{
    private int ticket=100; //不用设置成静态变量
    private Object obj=new Object();    //声明一个对象为锁

    @Override
    public void run() {
        while(true)
        {
            try {
                sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized(obj){  //互斥操作
                if (ticket > 0)
                {
                    System.out.println(Thread.currentThread().getName() + "卖票: " + ticket);
                    ticket--;
                }
                else break;
            }
        }
    }
}

Thread下可以考虑用WinThread.class当锁，而Runnable下可以考虑用this当锁(总之要分析是不是同一个锁)

自己的坑:不能把共享的数据当作锁(例如WinThread下的int ticket改成Integer后当锁)，这里还是会有问题

方法二:同步方法(代码略)

多声明一个对共享数据数据操作的方法，在方法的前面添加声明synchronized，而不是直接在run()前面加

1.同步方法中也涉及到同步锁，但锁是默认的

2.非静态的同步方法，锁是this

静态的同步方法，锁是当前类本身——xxx.class

 *              同步方法synchronized实现runnable接口
 *              private synchronized void 方法(){//普通同步方法的同步监视器是this
 *              //需要互斥的代码
 *          }

 *              同步方法synchronized实现继承Thread类
 *                  因为不同线程是Thread类的不同对象，所以一般要用静态
 *              private static synchronized void 方法(){//静态同步方法默认同步监视器是类本身
 *                  //需要互斥的代码
 *              }

同步的局限性:操作同步代码时，只能有一个线程参与，其他线程等待，相当于互斥量为1

单例模式的同步问题

死锁问题

方法二:Lock(锁) ---JDK5.0新增

class LockRunnable implements Runnable{
    private int ticket=100; //不用设置成静态变量
    private ReentrantLock lock=new ReentrantLock(true); //true为选择FIFO的公平
    @Override
    public void run() {
        while(true)
        {
            try {

                try {
                    sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                lock.lock();
                if (ticket > 0)
                {
                    System.out.println(Thread.currentThread().getName() + "卖票: " + ticket);
                    ticket--;
                }
                else break;
            }finally {
                lock.unlock();
            }
        }
    }
}

面试题:synchronized 与 Lock 的区别

相同:二者都可以解决线程安全问题

不同:synchronized机制在执行完相应的同步代码之后，自动的释放同步监视器

Lock需要手动的启动同步 .lock() ，同时结束同步也需要手动 .unlock()