Java线程同步

 

一、什么是线程同步

 现实生活中，我们会遇到“同一个资源，多个人都想使用”的问题。 比如：教室里，只有一台电脑，多个人都想使用。天然的解决办法就是，在电脑旁边，大家排队。前一人使用完后，后一人再使用。

 处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象。 这时候，我们就需要用到“线程同步”。 线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面的线程使用完毕后，下一个线程再使用。

由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突的问题。Java语言提供了专门机制以解决这种冲突，有效避免了同一个数据对象被多个线程同时访问造成的这种问题。

由于我们可以通过 private 关键字来保证数据对象只能被方法访问，所以我们只需针对方法提出一套机制，这套机制就是synchronized关键字，它包括两种用法：synchronized 方法和 synchronized 块。

 通过在方法声明中加入 synchronized关键字来声明，语法如下：

public  synchronized  void accessVal(int newVal);

 synchronized 方法控制对“对象的类成员变量”的访问：每个对象对应一把锁，每个 synchronized 方法都必须获得调用该方法的对象的锁方能执行，否则所属线程阻塞，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。

▪ synchronized块

 synchronized 方法的缺陷：若将一个大的方法声明为synchronized 将会大大影响效率。

Java 为我们提供了更好的解决办法，那就是 synchronized 块。 块可以让我们精确地控制到具体的“成员变量”，缩小同步的范围，提高效率。

 

synchronized(syncObject)
　  { 
　　 //允许访问控制的代码 
　  }

简单来说就是当多个线程调用一个资源的时候很容易出现问题，特别是当涉及到对资源内容的修改的时候，这个时候我们需要让线程一个一个的去调用，如何实现呢，就是当一个线程调用的时候其他的线程不能使用，这个时候的资源被一个线程占用处于锁定的状态，而其他的线程只能够等待。虽然这样会导致程序运行的速度变慢，但是保证了线程的安全性。 

下面的代码是一个典型的并行不当而错误的类型

public class getMony {
    public static void main(String[] args) {
        Account account=new Account(100,"lan");
        drawMony d1=new drawMony(80,account);
        drawMony d2=new drawMony(80,account);
        d1.start();
        d2.start();
    }
}
    class drawMony extends Thread{
        int drawNum;
        Account account;
        public drawMony(int drawNum,Account account){
            super();
            this.drawNum=drawNum;
            this.account=account;
        }
        public void run() {
            super.run();
            set();
        }
        void set(){
            if(account.mony-drawNum<0){
                System.out.println("没钱了");
                return;
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
                account.mony -=drawNum;
            System.out.println("还剩多少钱"+account.mony);
        }

    }

看上去没有问题其实输出的结果有时候可能是负数，这里就是线程并发的问题，但是要分析清楚问题出在哪里比如如果只是把 synchronized加到set方法上，那么结果仍然有错，分析可以得出加在set方法上只是锁定了取钱的这个对象，而我们应该锁定的是我们的账户，因此我们要在账户那里加上 synchronized块，就可以得到下面的代码

public class getMony {
    public static void main(String[] args) {
        Account account=new Account(100,"lan");
        drawMony d1=new drawMony(80,account);
        drawMony d2=new drawMony(80,account);
        d1.start();
        d2.start();
    }
}
    class drawMony extends Thread{
        int drawNum;
        Account account;
        public drawMony(int drawNum,Account account){
            super();
            this.drawNum=drawNum;
            this.account=account;
        }
        public void run() {
            super.run();
            set();
        }
        void set(){
            if(account.mony<0){
                return;
            }
            synchronized (account){
            if(account.mony-drawNum<0){
                System.out.println("没钱了");
                return;
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
                account.mony -=drawNum;
            System.out.println("还剩多少钱"+account.mony);
        }
        }

    }

这样我们就可以输出我们想要的内容，不会出现负数。

二、并发容器

有时候我们使用synchronized块的时候需要锁定一些容器比如链表数组什么的，这个时候我们并不需要在代码上声明将该容器锁定，而是调用Java中的until中的copywrite库，在创建新的容器的时候在上面加copywrite就行，比如copywriteArraylist

三、死锁问题

“死锁”指的是：

多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能进行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形。

因此， 某一个同步块需要同时拥有“两个以上对象的锁”时，就可能会发生“死锁”的问题。下面案例中，“化妆线程”需要同时拥有“镜子对象”、“口红对象”才能运行同步块。那么，实际运行时，“小丫的化妆线程”拥有了“镜子对象”，“大丫的化妆线程”拥有了“口红对象”，都在互相等待对方释放资源，才能化妆。这样，两个线程就形成了互相等待，无法继续运行的“死锁状态”。

死锁的解决方法也很简单，在一个锁里面不要有其他的对象锁，将其他的对象锁放在另一个对象锁的外面就可以解决这个问题。

四、并发协作

1、管程法

   多线程环境下，我们经常需要多个线程的并发和协作。这个时候，就需要了解一个重要的多线程并发协作模型“生产者/消费者模式”。

Ø 什么是生产者?

      生产者指的是负责生产数据的模块(这里模块可能是：方法、对象、线程、进程)。

Ø 什么是消费者?

      消费者指的是负责处理数据的模块(这里模块可能是：方法、对象、线程、进程)。

Ø 什么是缓冲区?

      消费者不能直接使用生产者的数据，它们之间有个“缓冲区”。生产者将生产好的数据放入“缓冲区”，消费者从“缓冲区”拿要处理的数据。

 缓冲区是实现并发的核心，缓冲区的设置有3个好处：

Ø 实现线程的并发协作

      有了缓冲区以后，生产者线程只需要往缓冲区里面放置数据，而不需要管消费者消费的情况;同样，消费者只需要从缓冲区拿数据处理即可，也不需要管生产者生产的情况。 这样，就从逻辑上实现了“生产者线程”和“消费者线程”的分离。

Ø 解耦了生产者和消费者

      生产者不需要和消费者直接打交道。

Ø 解决忙闲不均，提高效率

      生产者生产数据慢时，缓冲区仍有数据，不影响消费者消费;消费者处理数据慢时，生产者仍然可以继续往缓冲区里面放置数据 。

public class mangerWay {
    public static void main(String[] args) {
        allDate date=new allDate();
        Protector p1=new Protector(date);
        Shopper s1=new Shopper(date);
        p1.start();
        s1.start();
    }
}
//生产者
class Protector extends Thread{
    allDate a1=new allDate();
    public Protector(allDate a1){
        this.a1=a1;
    }
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println("生产馒头"+i);
            Date d=new Date(i);
            a1.push(d);
        }
    }
}
//消费者
class Shopper extends Thread{
    allDate a2=new allDate();
    public Shopper(allDate a2){
        this.a2=a2;
    }
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println("消费馒头"+i);
            a2.get();
        }
    }
}
//缓存区
class allDate{
    Date[] dates=new Date[10];
    //存入数据
    int count=0;
    public synchronized void push(Date date){
        if(count==dates.length){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        dates[count]=date;
        count++;
        this.notify();//唤醒消费者去购买
    }
    public synchronized Date get(){
        if(count==0){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        count--;
        this.notify();//唤醒生产者去生产
        return dates[count];
    }
}
//数据
class Date{
    int id;
    public Date(int id){
        this.id=id;
    }
}

线程并发协作(也叫线程通信)，通常用于生产者/消费者模式，情景如下：

      1. 生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件。

      2. 对于生产者，没有生产产品之前，消费者要进入等待状态。而生产了产品之后，又需要马上通知消费者消费。

      3. 对于消费者，在消费之后，要通知生产者已经消费结束，需要继续生产新产品以供消费。

      4. 在生产者消费者问题中，仅有synchronized是不够的。

        · synchronized可阻止并发更新同一个共享资源，实现了同步;

        · synchronized不能用来实现不同线程之间的消息传递(通信)。

使用wait以及notify/notifyall方法来等待或者唤醒，

二、信号灯法

即像红绿灯那样，用一个符号来表示哪个线程等待，哪个线程开始执行，具体的操作和上个方法差不多。