创建线程方式二:实现Runnable接口
1. 定义类实现Runnable接口。
2.覆盖接口中的run方法,将线程的任务代码封装到run方法中。
3. 通过Thread类创建线程对象,并将Runnable接口的子类对象作为Thread类的构造函数的参数进行传递。为什么?
因为线程的任务都封装在Runnable接口子类对象的run方法中。
所以要在线程对象创建时就必须明确要运行的任务。
4. 调用线程对象的start方法开启线程。
实现Runnable接口的好处:
1. 将线程的任务从线程的子类中分离出来,进行了单独的封装,
按照面向对象的思想将任务封装成对象。
2. 避免了Java单继承的局限性。所以,创建线程的第二种方式较为常用。
线程都有自己默认的名称。即:thread-编号。编号从0开始。
示例:
1. //准备扩展Demo类的功能,让其中的内容可以作为线程的任务执行。
2. //通过接口的形式完成。
public class One {
public static void main(String[] args) {
Demo demo = new Demo();
Thread t1 = new Thread(demo);
Thread t2 = new Thread(demo);
t1.start();
t2.start();
// Thread-1...0
// Thread-1...1
// Thread-0...0
// Thread-0...1
}
}
class Demo implements Runnable {
@Override
public void run() {
show();
}
private void show() {
for (int x = 0; x < 8; x++) {
// currentThread()返回对当前正在执行的线程对象的引用。
//返回该线程的名称。getName()
System.out.println(Thread.currentThread().getName() + "..." + x);
}
}
}
5.2线程安全问题
5.2.1 线程安全问题产生的原因
需求:模拟4个线程同时卖100张票。
代码:
public class One {
public static void main(String[] args) {
Ticket t = new Ticket();
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
Thread t3 = new Thread(t);
Thread t4 = new Thread(t);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
class Ticket implements Runnable {
private int num = 100;
@Override
public void run() {
while (true) {
if (num > 0) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "...sale..." + num--);
}
}
}
}
运行结果:(最后几行的日志)
Thread-3...sale...2
Thread-1...sale...1
Thread-0...sale...0
Thread-3...sale...-2
Thread-2...sale...-1
原因分析:
出现上图安全问题的原因在于Thread-0通过了if判断后,在执行到“num--”语句之前,
num此时仍等于1。 CPU切换到Thread-1、Thread-2、Thread-3之后,这些线程依然可以通过if判断,从而执行“num--”的操作,因而出现了0、-1、-2的情况。
线程安全问题产生的原因:
1. 多个线程在操作共享的数据。
2. 操作共享数据的线程代码有多条。
当一个线程在执行操作共享数据的多条代码过程中,其他线程参与了运算,就会导致线程安全问题的产生。
5.2.2 线程安全问题的解决方案
思路:
就是将多条操作共享数据的线程代码封装起来,当有线程在执行这些代码的时候,其他线程不可以参与运算。必须要当前线程把这些代码都执行完毕后,其他线程才可以参与运算。
在java中,用同步代码块就可以解决这个问题。将共享数据的线程代码封装。
同步代码块的格式:
synchronized(对象){
需要被同步的代码;
}
同步的好处:解决了线程的安全问题。
同步的弊端:当线程相当多时,因为每个线程都会去判断同步上的锁,这是很耗费资源的,无形中会降低程序的运行效率。
同步的前提:必须有多个线程并使用同一个锁。
修改后代码:
class Ticket implements Runnable {
private int num = 100;
Object obj = new Object();
@Override
public void run() {
while (true) {
synchronized (obj) {
if (num > 0) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "...sale..." + num--);
}
}
}
}
}
运行结果:(最后几行日志)
Thread-3...sale...3
Thread-3...sale...2
Thread-3...sale...1
原因分析:
上图显示安全问题已被解决,原因在于Object对象相当于是一把锁,只有抢到锁的线程,才能进入同步代码块向下执行。
因此,当num=1时,CPU切换到某个线程后,如上图的Thread-3线程,其他线程将无法通过同步代码块继而进行if判断语句,只有等到Thread-3线程执行完“num--”操作(此后num的值为0),并且跳出同步代码块后,才能抢到锁。其他线程即使抢到锁,然而,此时num值已为0,也就无法通过if语句判断,从而无法再执行“num--”的操作了,也就不会出现0、-1、-2等情况了。
利用同步代码块解决安全问题案例:
需求:储户,两个,每个都到银行存钱,每次存100,共存三次。
代码:
public class One {
public static void main(String[] args) {
Cus c = new Cus();
Thread t1 = new Thread(c);
Thread t2 = new Thread(c);
t1.start();
t2.start();
}
}
class Bank {
private int sum;
public void add(int num) {
synchronized (this) {//同步函数,默认this
sum = sum + num;
System.out.println("sum =" + sum);
}
}
}
class Cus implements Runnable {
private Bank b = new Bank();//创建bank类
@Override
public void run() {
for (int x = 0; x < 3; x++) {
b.add(100);
}
}
}
运行结果:
sum =100
sum =200
sum =300
sum =400
sum =500
sum =600
原因分析:
由如下代码中可以看到,同步代码块中的语句,存在可能有多个线程同时操作共享数据(sum)的情况,通过同步代码块即可解决存在的安全问题。
如果不设置同步代码块,出现的结果如下:
sum =200
sum =200
sum =300
sum =400
sum =500
sum =600
安全问题的另一种解决方案:同步代码块
格式:在函数上加上synchronized修饰符即可。
示例:
class Bank {
private int sum;
public synchronized void add(int num) {
sum = sum + num;
System.out.println("sum =" + sum);
}
}
运行结果:
sum =100
sum =200
sum =300
sum =400
sum =500
sum =600
同步函数和同步代码块的区别:
1. 同步函数的锁是固定的this。
2. 同步代码块的锁是任意的对象。 建议使用同步代码块。
由于同步函数的锁是固定的this,同步代码块的锁是任意的对象,那么如果同步函数和同步代码块都使用this作为锁,就可以实现同步。
示例:
public class One {
public static void main(String[] args) {
Ticket t = new Ticket();
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
t1.start();
//下面这条语句一定要执行。因为可能线程t1尚未真正启动,flag已经设置为false,那么当t1执行的时候,就会按照flag为false的情况执行,
// 线程t2也按照flag为false的情况执行,实验就达不到目的了。
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
t.flag = false;
t2.start();
}
}
class Ticket implements Runnable {
private int num = 10;
boolean flag = true;
@Override
public void run() {
if (flag) {
while (true) {
synchronized (this) {//同步函数使用this作为锁
if (num > 0) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "...sale..." + num--);
}
}
}
} else {
while (true)
show();
}
}
//同步代码块
public synchronized void show() {
if (num > 0) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "...function..." + num--);
}
}
}
运行结果:
Thread-0...sale...10
Thread-0...sale...9
Thread-0...sale...8
Thread-0...sale...7
Thread-0...sale...6
Thread-0...sale...5
Thread-0...sale...4
Thread-1...function...3
Thread-1...function...2
Thread-1...function...1
静态的同步函数使用的锁是该函数所属字节码文件对象,可以用getClass方法获取,也可以用当前类名.class表示。
示例:
class Ticket implements Runnable {
private static int num = 15;
boolean flag = true;
@Override
public void run() {
if (flag) {
while (true) {
synchronized (Ticket.class) {
if (num > 0) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "...sale..." + num--);
}
}
}
} else {
while (true)
show();
}
}
//同步代码块
public static synchronized void show() {
if (num > 0) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "...function..." + num--);
}
}
}
运行结果:
Thread-0...sale...15
Thread-0...sale...14
Thread-0...sale...13
Thread-0...sale...12
Thread-0...sale...11
Thread-0...sale...10
Thread-0...sale...9
Thread-0...sale...8
Thread-0...sale...7
Thread-0...sale...6
Thread-0...sale...5
Thread-0...sale...4
Thread-0...sale...3
Thread-0...sale...2
Thread-0...sale...1
5.2.3 多线程下的单例模式
饿汉式:
class Single{
private static final Single s = new Single();
private Single(){}
public static Single getInstance(){
return s;
}
}
P.S.
饿汉式不存在安全问题,因为不存在多个线程共同操作数据的情况。
懒汉式:
class Single {
private static Single s = null;
private Single() {
}
public static Single getInstance() {
if (s == null) {
synchronized (Single.class) {
//进入同步锁后,再次判断是否已经创建了对象
if (s == null) {
s = new Single();
}
}
}
return s;
}
}
P.S.
懒汉式存在安全问题,可以使用同步函数解决。
但若直接使用同步函数,则效率较低,因为每次都需要判断。
但若采取如下方式,即可提升效率。
原因在于任何一个线程在执行到第一个if判断语句时,如果Single对象已经创建,则直接获取即可,而不用判断是否能够获取锁,相对于上面使用同步函数的方法就提升了效率。如果当前线程发现Single对象尚未创建,则再判断是否能够获取锁。
1. 如果能够获取锁,那么就通过第二个if判断语句判断是否需要创建Single对象。因为可能当此线程获取到锁之前,已经有一个线程创建完Single对象,并且放弃了锁。此时它便没有必要再去创建,可以直接跳出同步代码块,放弃锁,获取Single对象即可。如果有必要,则再创建。
2. 如果不能获取到锁,则等待,直至能够获取到锁为止,再按步骤一执行。
5.2.4 死锁示例
死锁常见情景之一:同步的嵌套。
示例1:
public class One {
public static void main(String[] args) {
Ticket t = new Ticket();
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
t1.start();
//下面这条语句一定要执行。因为可能线程t1尚未真正启动,flag已经设置为false,那么当t1执行的时候,就会按照flag为false的情况执行,
// 线程t2也按照flag为false的情况执行,实验就达不到目的了。
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
t.flag = false;
t2.start();
}
}
class Ticket implements Runnable {
private static int num = 110;
Object obj = new Object();
boolean flag = true;
@Override
public void run() {
if (flag) {
while (true) {
// run方法中的同步函数需要获取obj对象锁
synchronized (obj) {
show();
}
}
} else {
while (true)
show();
}
}
//执行代码块show方法则必须获取this对象锁
public synchronized void show() {
synchronized (obj) {
if (num > 0) {
}
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "...function..." + num--);
}
}
}
运行结果:
Thread-0...function...110
原因分析:
由上图可以看到程序已经被锁死,无法向下执行。
1由下图代码可以看到,run方法中的同步函数需要获取obj对象锁,才能执行代码块中的show方法。
2而执行show方法则必须获取this对象锁,然后才能执行其中的同步代码块。
3当线程t1获取到obj对象锁执行同步代码块,
4线程t2获取到this对象锁执行show方法。
5同步代码块中的show方法因无法获取到this对象锁无法执行,show方法中的同步代码块因无法获取到obj对象锁无法执行,就会产生死锁。
简言之,t1拿到了obj锁,同时t2拿到了this锁,然后t1拿不到this锁,执行中止
示例2:
public class One {
public static void main(String[] args) {
Test a = new Test(true);
Test b = new Test(false);
Thread t1 = new Thread(a);
Thread t2 = new Thread(b);
t1.start();
t2.start();
}
}
class Test implements Runnable {
private boolean flag;
Test(boolean flag) {
this.flag = flag;
}
@Override
public void run() {
if (flag) {
while (true) {
synchronized (MyLock.locka) {
System.out.println(Thread.currentThread().getName() + "...if locka...");
synchronized (MyLock.lockb) {
System.out.println(Thread.currentThread().getName() + "...if lockb...");
}
}
}
} else {
synchronized (MyLock.lockb) {
System.out.println(Thread.currentThread().getName() + "...if lockb...");
synchronized (MyLock.locka) {
System.out.println(Thread.currentThread().getName() + "...if locka...");
}
}
}
}
}
class MyLock {
public static final Object locka = new Object();
public static final Object lockb = new Object();
}
运行结果:
Thread-0...if locka...
Thread-1...if lockb...
分析:
t1拿到locka锁,t2拿到lockb锁,程序终止。