多线程的基本使用
程序员文章站
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();
}
}
测试结果:
可以看到实现了效果.
上一篇: Java 锁-Lock接口简介
下一篇: linux网络高级编程之非阻塞