多线程的基本使用

一.使用继承Thread类开启多线程

package com.zk.Thread;

/**
 * 多线程的使用一
 *
 * @author zk
 * @date 2020-9-8
 */
public class ThreadA {
    /**
     * 第一种,继承Thread类,实现run方法,调用start方法启动线程
     *
     * @param args
     */
    public static void main(String[] args) {
        new Thread(() -> {
            for (int i = 0; i < 50; i++) {
                System.out.println("线程A" + i);
            }
        }).start();
        new Thread(() -> {
            for (int i = 50; i < 100; i++) {
                System.out.println("线程B" + i);
            }
        }).start();
    }
}

二.使用实现Runnable接口开启多线程

package com.zk.Thread;

/**
 * 多线程的使用二
 *
 * @author zk
 * @date 2020-9-8
 */
public class ThreadB {
    /**
     * 第二种,实现Runnable接口,实现run方法,相当于定义了一个任务,
     * 然后新建Thread,把这个任务传递给Thread,最后调用start方法启动线程
     *
     * @param args
     */
    public static void main(String[] args) {
        Runnable r1 = () -> {
            for (int i = 0; i < 50; i++) {
                System.out.println("线程A" + i);
            }
        };
        Runnable r2 = () -> {
            for (int i = 50; i < 100; i++) {
                System.out.println("线程B" + i);
            }
        };
        Thread t1 = new Thread(r1);
        Thread t2 = new Thread(r2);
        t1.start();
        t2.start();
    }
}

三.线程安全问题

1.线程安全问题案例,有一个火车站卖一趟火车的票,一共有十张票,两个窗口同时在卖票,代码如下:

售票窗口类:

package com.zk.Thread;

/**
 * 售票窗口
 *
 * @author zk
 * @date 2020-9-8
 */
public class SaleWindow implements Runnable {
    private int sum = 10;

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            if (sum > 0) {
                System.out.println(Thread.currentThread().getName() + "卖了编号为" + sum + "的火车票");
                sum--;
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

测试类:

package com.zk.Thread;

/**
 * 火车卖票案例
 *
 * @author zk
 * @date 2020-9-8
 */
public class SaleWindowTest {
    public static void main(String[] args) {
        SaleWindow s = new SaleWindow();
        Thread t1 = new Thread(s);
        t1.setName("窗口一");
        Thread t2 = new Thread(s);
        t2.setName("窗口二");
        t1.start();
        t2.start();
    }
}

运行结果:

可以看到窗口一和窗口二都在卖票,但是会有同时卖掉同一个编号票的情况,这种情况是不正确的,这就是线程安全问题.

2.使用同步锁解决线程安全问题

1).使用同步代码块解决线程安全问题

package com.zk.Thread;

/**
 * 售票窗口
 *
 * @author zk
 * @date 2020-9-8
 */
public class SaleWindow implements Runnable {
    private int sum = 10;

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            //同步代码块,锁是this
            synchronized (this){
                if (sum > 0) {
                    System.out.println(Thread.currentThread().getName() + "卖了编号为" + sum + "的火车票");
                    sum--;
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

运行结果如下:

可以看到已经没有了卖同一编号票的情况了

2).使用同步方法解决线程安全问题

这个和同步代码块基本类似

package com.zk.Thread;

/**
 * 售票窗口
 *
 * @author zk
 * @date 2020-9-8
 */
public class SaleWindow implements Runnable {
    private int sum = 10;

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            sale();
        }
    }

    /**
     * 同步方法,锁默认是this对象
     */
    private synchronized void sale() {
        if (sum > 0) {
            System.out.println(Thread.currentThread().getName() + "卖了编号为" + sum + "的火车票");
            sum--;
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

运行后看结果也是正确的,没有两个窗口卖同一编号票的情况.

3).StringBuffer和StringBuilder

这两个类经常在字符拼接的时候用到,因为String的效率太低了.我门通常说StringBuffer是线程安全的,StringBuilder是线程不安全的,为什么呢,看看源码的对比:

可以看到StringBuffer类中的大部分方法都是同步方法.

注意:使用同步锁虽然解决了线程安全问题,但是同时也降低了程序运行的效率,在实际应用中需要根据具体的业务权衡利弊.

四.线程间的通信--等待唤醒机制

主要用到的是Object类中的三个方法:wait();notify();notifyall();

案例:让上面的窗口循环卖票,也就是窗口A卖一张票,接着窗口B卖一张票,然后窗口A再卖一张票...

上代码:

package com.zk.Thread;

/**
 * 锁对象
 * 
 * @author zk
 * @date 2020-9-8
 */
public class MyLock {
}

package com.zk.Thread;

/**
 * 售票窗口
 *
 * @author zk
 * @date 2020-9-8
 */
public class SaleWindow implements Runnable {
    private int sum = 10;

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            synchronized (MyLock.class) {
                if (sum > 0) {
                    System.out.println(Thread.currentThread().getName() + "卖了编号为" + sum + "的火车票");
                    sum--;
                    //唤醒线程
                    MyLock.class.notify();
                    try {
                        //让线程等待
                        MyLock.class.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

测试类:

package com.zk.Thread;

/**
 * 火车卖票案例
 *
 * @author zk
 * @date 2020-9-8
 */
public class SaleWindowTest {
    public static void main(String[] args) {
        SaleWindow s = new SaleWindow();
        Thread t1 = new Thread(s);
        t1.setName("窗口一");
        Thread t2 = new Thread(s);
        t2.setName("窗口二");
        t1.start();
        t2.start();
    }
}

测试结果:

可以看到实现了效果.