多线程

多线程

 线程安全

如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

可以通过卖票这个实例演示一下

public class Demo01 {
    public static void main(String[] args) {
        //创建线程任务
        Ticket04 t=new Ticket04();
        //创三条线程        
        Thread t1=new Thread(t);
        Thread t2=new Thread(t);
        Thread t3=new Thread(t);
        //开启线程
        t1.start();
        t2.start();
        t3.start();        
    }
}

public class Ticket implements Runnable{
    //共享数据
　　//此处将num封装起来，作为全部方法的全局变量来使用
    private int num=100;
    //卖票
    public void run() {
        while(true){            
            if(num>0){
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"卖出了第"+num--+"张票");
            }
        }        
    }
}

运行结果如下：

此时会发现票被多卖了，造成这个原因的问题就是没有考虑线程安全的问题，也就是线程不安全，画图如下：当余票为1的时候，t1会进入程序，num>0,符合，继续执行，等待500毫秒，卖出第1张票，t1等待中，t2、t3相继进入，全都符合num>0,继续执行，输出卖出第0张票，卖出第-1张票                                                                                         

其实，线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全。

 

线程同步（线程安全处理Synchronized）

 

java中提供了线程同步机制，它能够解决上述的线程安全问题。

 

线程同步的方式有两种：

 

方式1：同步代码块

 

方式2：同步方法

 

 

同步代码块: 在代码块声明上 加上synchronized

 

synchronized (锁对象) {

 

可能会产生线程安全问题的代码

 

}

 

同步代码块中的锁对象可以是任意的对象；但多个线程时，要使用同一个锁对象才能够保证线程安全。

 

 

 

public class Ticket02 implements Runnable{
    //共享数据
    private int num=100;
    //锁对象
    private Object obj=new Object();
    //卖票
    public void run() {        
        while(true){
　　　　　　//同步代码块
            synchronized(obj){            
            if(num>0){
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                    System.out.println(Thread.currentThread().getName()+"卖出了第"+num--+"张票");
                }
            }
        }        
    }
}

当余票为1的时候，t1进入循环，先看有没有锁，有锁，带着锁执行下面的程序，输出卖出了第一张票，t2和t3一次进入程序的时候，都先看有没有锁，没有锁就等待前面程序执行完毕再执行，查看条件num=0；不符合循环，直接退出

1.1.1 同步方法

同步方法：在方法声明上加上synchronized

public synchronized void method(){

    可能会产生线程安全问题的代码

}

同步方法中的锁对象是 this

public class Ticket03 implements Runnable{
    //共享数据
    private int num=100;
    //卖票
    public void run() {
        while(true){
            sale();
        }        
    }
　　//同步方法
    public synchronized void sale(){        
        if(num>0){
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"卖出了第"+num--+"张票");
        }
    }
}

Lock接口

Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。

常用方法：

lock();   获取锁

unlock();  释放锁

Lock提供了一个更加面对对象的锁，在该锁中提供了更多的操作锁的功能。

我们使用Lock接口，以及其中的lock()方法和unlock()方法替代同步，

public class Ticket04 implements Runnable{
    //共享数据
    private int num=100;
    private Lock lock=new ReentrantLock();
    //卖票
    public void run() {
        while(true){
            lock.lock();        
            if(num>0){
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"卖出了第"+num--+"张票");
            }
            //释放锁
            lock.unlock();
        }        
    }
}