欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

多线程的基本使用

程序员文章站 2022-05-05 16:33:32
...

一.使用继承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();
    }
}

测试结果:

多线程的基本使用

可以看到实现了效果.