多线程学习(十一)-----资源共享与线程同步（重点）

• ★多线程共享数据

  1、 在多线程操作中,多个线程可能会同时处理多个资源,这就是多线程的共享数据.
  2、 多线程共享数据时,会发生线程不安全的情况,
  3、 多线程共享数据必须使用同步.

• ★线程同步

  1、同步就是指多个线程在在同一个时间段内只能一个线程执行指定代码,其他线程
  2、要在此线程完成之后才能继续执行.

• 同步的三种实现方式

         1.通过同步代码块来实现
         	 
         	 	同步代码块	synchronized ( this ) { } 参数是一个对象(同步锁),当一个线程
         	 	执行时,代码块会锁上阻止其他线程执行,在该代码块执行结束时,会解放该代码块;
         
         2.通过同步方法来实现
        
         		   private synchronized void method ( ) { }
        
         3.通过 Lock接口的实现类( ReentrantRock 类)来实现
  

• ★同步准则:

  1、同步代码块要尽量保持简短,把不随数据变化的代码移除同步代码块,

  2、不要阻塞,

  3、在持有锁的情况下,不要调用其他类的方法.

• ★注意:

  1、多线程共享数据必须使用同步.但是使用同步会牺牲性能,来换取安全.

  2、同步代码块要尽量的保持简短,把不随数据变化的代码移除同步代码块,不要阻塞.

  3、在一个同步方法中,调用了另一个类的同步方法,会造成死锁 .

案例:

package com.DuoXianCheng;

import sun.security.krb5.internal.Ticket;

import java.sql.SQLOutput;
import java.util.concurrent.locks.ReentrantLock;

public class ThreadDemo4 {
    /**
     * ★多线程共享数据
     *      在多线程操作中,多个线程可能会同时处理多个资源,这就是多线程的共享数据.
     *      ·多线程共享数据时,会发生线程不安全的情况,
     *      ·多线程共享数据必须使用同步.
     * ★线程同步
     *      同步就是指多个线程在在同一个时间段内只能一个线程执行指定代码,其他线程
     *      要在此线程完成之后才能继续执行.
     *      ·同步的三种实现方式
     *          1.通过同步代码块来实现
     *              同步代码块synchronized ( this ) { } 参数是一个对象(同步锁),当一个线程执行时,
     *              代码块会锁上阻止其他线程执行,在该代码块执行结束时,会解放该代码块;
     *          2.通过同步方法来实现
     *              private synchronized void method ( ) { }
     *          3.通过 Lock接口的实现类( ReentrantRock 类)来实现
     * ★同步准则:
     *      ·同步代码块要尽量保持简短,把不随数据变化的代码移除同步代码块,
     *      ·不要阻塞,
     *      ·在持有锁的情况下,不要调用其他类的方法.
     * ★注意:
     *     ·多线程共享数据必须使用同步.但是使用同步会牺牲性能,来换取安全.
     *     ·同步代码块要尽量的保持简短,把不随数据变化的代码移除同步代码块,不要阻塞.
     *     ·在一个同步方法中,调用了另一个类的同步方法,会造成死锁 .
     * @param args
     */
    public static void main(String[] args) {
        MyRunnable4 myRunnable4 = new MyRunnable4();

        Thread thread1 = new Thread(myRunnable4);
        Thread thread2 = new Thread(myRunnable4);
        thread1.start();
        thread2.start();
    }
}

class  MyRunnable4 implements Runnable{
    private int ticket = 10;
   //第一种:
   // private  Object object = new Object(); //同步锁
    @Override
    public void run() {
        for (int i = 0; i < 300; i++) {
            if(ticket>0){
                //同步代码块synchronized(){}参数是一个对象,当一个线程执行时,
                //代码块会锁上阻止其他线程执行,在该代码块执行结束时,会解放该代码块;
               /* synchronized (this){
                System.out.println("你所购买的票剩余:"+ticket+"张");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                --ticket;
                }*/

             	
               //调用同步方法实现同步 private synchronized void method(){}
               //同步方法
               // method();

               
               //通过Lock接口的实现类(ReentrantLock类)实现
                method2();

            } else{
                return;
            }
        }
    }
    //第二种:同步方法 (synchronized关键字 设置同步方法)
    private synchronized void method(){
            System.out.println("你所购买的票剩余:"+ticket+"张");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            --ticket;
    }

	//第三种
    //通过Lock接口的实现类(ReentrantLock类)实现
    ReentrantLock lock=new ReentrantLock();		//实例化一个ReentrantLock类的对象

    private  void method2(){
        //添加锁
        lock.lock();
        try {
            System.out.println("你所购买的票剩余:" + ticket + "张");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            --ticket;
        }finally {
            //释放锁
            lock.unlock();
        }
    }
}