【Java并发编程一】线程安全问题

1.多线程的实现

 

多线程有两种实现方式：

1.1.继承Thread类 =>示例：A a=new A(); a.start();

 

1.2.实现Runnable接口 =>示例：A a=new A(); new Thread(A,自定义线程名称).start();

 

其实Thread和Runnable都实现了run方法，这种操作模式其实就是代理模式

获取当前线程名称：Thread.currentThread().getName()

调用线程是thread.start(),真正执行线程是 thread.run()

 

具体代码：

/**
 * 继承Thread类
 * @date 2019/3/29 11:19
 */
public class SimpleThread extends Thread{

    @Override
    public void run() {
        super.run();
        Thread thread = Thread.currentThread();
        System.out.println("Thread =>当前执行的线程为："+thread.getName());
    }
}

/**
 * 实现Runnable接口
 * @date 2019/3/29 11:28
 */
public class SimpleRunnable implements Runnable {

    @Override
    public void run() {
         Thread thread = Thread.currentThread();
         System.out.println("Runnable =>当前执行的线程为："+thread.getName());
    }
}

public class TestMain {


    /**执行线程示例1*/
    private static void callSimpleThread(){
        int index=10;
        for (int i = 0; i < index; i++) {
             Thread thread=new SimpleThread();
             thread.start();
        }
    }

    /**执行线程示例1*/
    private static void callSimpleRunnable(){
        int index=10;
        for (int i = 0; i < index; i++) {
            SimpleRunnable simpleRunnable=new SimpleRunnable();
            new Thread(simpleRunnable,"Runnable-"+i).start();
        }
    }

    public static void main(String[] args) {

        callSimpleThread();

        callSimpleRunnable();
    }

}

 

 

2.多线程安全问题

 

2.1线程不安全示例

多线程最容易产生的一个问题就是线程安全问题，下面使用一个卖票的例子来体现。

场景描述：现在有两个售票员，一共卖10张车票

public class SellTicket extends Thread {

    private static int NUMBER = 10;
    public SellTicket(String name) {
        super(name);
    }

    @Override
    public void run() {
        String s = "线程：" + Thread.currentThread().getName();

        while (NUMBER > 0) {
            int i = NUMBER--;
            System.out.println(s + " => 卖了第" + i + "号票");
        }

        System.out.println(s + ",票已经卖完");
        super.run();
    }


    public static void main(String[] args) {

        SellTicket thread1 = new SellTicket("售票员A");
        thread1.start();

        SellTicket thread2 = new SellTicket("售票员B");
        thread2.start();

    }

}

执行结果如下：

我们发现售票员A 和售票员B都卖了10号票，这就是线程不安全导致的结果

 

 

2.2线程不安全解决方法

方案一：使用同步代码解决
格式：synchronized(锁对象){需要被同步的代码}
锁对象可以为this锁，也可以自定义对象锁

方案二：使用同步函数解决
同步函数就是使用synchronized修饰一个函数

  

下面采用同步代码块解决

public class SafetySellTicket extends Thread {

    private static int NUMBER = 10;

    @Override
    public  void run() {
        String s = "线程：" + Thread.currentThread().getName();

        while (NUMBER > 0) {
            synchronized (this) {
                if (NUMBER > 0) {
                    int i = NUMBER--;
                    System.out.println(s + " => 卖了第" + i + "号票");
                } else {
                    System.out.println(s + ",票已经卖完");
                    break;
                }

            }
        }
        super.run();
    }


    public static void main(String[] args) {

        SafetySellTicket thread1 = new SafetySellTicket();
        thread1.start();

        SafetySellTicket thread2 = new SafetySellTicket();
        thread2.start();

    }

}