线程同步&线程池

线程同步&线程池
线程同步

线程不同步会出现的问题：

当多个线程操作同一资源时，会出现重复操作和和操作不存在的资源的问题，为了规避这一问题就需要线程的同步操作来实现资源的共同使用。

线程同步：

当多个线程操作同一资源时，给操作该资源的代码加上一把锁，当有一个线程拿到这把锁后，其他线程都不能操作带锁的资源代码，直至拿到锁的线程释放锁。

线程同步实现的3种方式：

同步代码块
synchornized(obj){
//涉及操作同一资源的代码
}
注：没有静态的同步代码块
obj: 任意类型的对象，相当于一把锁，操作同一资源的而线程必须使用同一把锁。
如何保证多个线程使用同一把锁？
在设置线程任务，即定义线程对象时在成员变量的位置上声明一个对象，将声明的变量放在sychornized代码块中
/**
模拟买票功能，开启多个线程，同时买一百张票
/
public class SaleTicket implements Runnable{
/
不同对象使用同一个变量
/
private static int ticket=100 ;

    /**
     *不同线程使用同一个锁对象
     */
    private Object obj = new Object();
    @Override
    public void run() {
        while(true) {
            /**
             * 使用synchornized(obj) {} 代码块
             */
            synchronized (obj) {
                if (ticket > 0) {
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "sale=====" + ticket);
                    ticket--;
                }
            }
        }
    }
}


public class SaleTicketDemoTest {
    public static void main(String[] args) {
        SaleTicket sale = new SaleTicket();
        //开启3个线程操作同一对象，从而操作同一资源
        Thread th1 = new Thread(sale);
        Thread th2 = new Thread(sale);
        Thread th3 = new Thread(sale);
        th1.start();
        th2.start();
        th3.start();
    }
}

同步方法
public synchornied void 方法名(){
//涉及操作同一资源的方法
}
同步方法的锁：
同步方法的锁使用的是this对象，即new Thread(Xxx) 的Xxx对象
package com.test.java;

/**
 *模拟买票功能，开启多个线程，同时买一百张票
 */

public class SaleTicket implements Runnable{
    /*
    不同对象使用同一个变量
     */
    private static int ticket=100 ;

    /**
     *不同线程使用同一个锁对象
     */
    private Object obj = new Object();
    @Override
    public void run() {
        while(true) {
                saleTicket();
        }
    }
    /**
     * 定义个个同步方法 public snychonized void XXX(){}
     */
    public synchronized void saleTicket() {
        if (ticket > 0) {
            try {
                Thread.sleep(500);

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "sale=====" + ticket);
            ticket--;
        }
    }
}

静态的同步方法
public static sychornized xxx(){
//涉及操作共同资源的代码
}
静态同步方法的锁是类名.class对象
package com.test.java;

/**
 *模拟买票功能，开启多个线程，同时买一百张票
 */

public class SaleTicket implements Runnable{
    /*
    不同对象使用同一个变量
     */
    private static int ticket=100 ;

    /**
     *不同线程使用同一个锁对象
     */
    private Object obj = new Object();
    @Override
    public void run() {
        while(true) {
                saleTicket();
        }


    /**
     * 静态同步方法
     */

    public static synchronized void saleTicket() {
        if (ticket > 0) {
            try {
                Thread.sleep(500);

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "sale=====" + ticket);
            ticket--;
        }
    }
}

锁机制
Jdk1.5后在java.util.concurrent.locks
lock的好处：解决了当共享资源的锁一直未被释放，其他线程无限等待的问题。
当多个线程都只是进行读操作，所以当一个线程在进行读操作时，其他线程只能等待无法进行读操作。因此就需要一种机制来使得多个线程都只是进行读操作时，线程之间不会发生冲突，通过Lock就可以办到
Lock和synchornized的区别：
1. Lock不是Java语言内置的，synchronized是Java语言的关键字，因此是内置特性。Lock是一个类，通过这个类可以实现同步访问；
  1. Lock和synchronized有一点非常大的不同，采用synchronized不需要用户去手动释放锁，当synchronized方法或者synchronized代码块执行完之后，系统会自动让线程释放对锁的占用；而Lock则必须要用户去手动释放锁，如果没有主动释放锁，就有可能导致出现死锁现象。
lock的特点：
1. 采用Lock，必须主动去释放锁，并且在发生异常时，不会自动释放锁。因此一般来说，使用Lock必须在try{}catch{}块中进行，并且将释放锁的操作放在finally块中进行，以保证锁一定被被释放，防止死锁的发生。通常使用Lock来进行同步的话

线程池

猜你喜欢