线程安全---Day23
最近忙着备考大学四年最后的两科,昨天刚考完大学所有的考试,但是大学专业是机械,但是自己热衷于it行业,想往it行业走,希望毕业后能成功进入到it行业,只希望毕业能找到一份java开发工程师的工作,这样我才能专研和学习到更高深的技术.希望在毕业前能学到一点java的精髓,让我可以成功进入到it行业,加油~
线程问题:
1 package demosummary.threadsafety;
2
3 public class ticket implements runnable{
4 //定义票数
5 private int ticket = 100;
6 /**
7 * 执行卖票方法
8 */
9 @override
10 public void run() {
11 //卖票窗口永久开启
12 while (true) {
13 //判断票是否卖完
14 if (ticket > 0) {
15 try {
16 //三秒卖一张票
17 thread.sleep(3000);
18 } catch (interruptedexception e) {
19 e.printstacktrace();
20 }
21 string name = thread.currentthread().getname();
22 system.out.println(name+"正在卖:"+ticket--);
23 }
24 }
25 }
26 }
27
28
29
30
31 package demosummary.threadsafety;
32
33 public class tickettest {
34 public static void main(string[] args) {
35 //创建线程任务对象
36 ticket ticket = new ticket();
37 //创建三个窗口对象
38 thread t1 = new thread(ticket, "窗口1");
39 thread t2 = new thread(ticket, "窗口2");
40 thread t3 = new thread(ticket, "窗口3");
41 //启用窗口来卖票
42 t1.start();
43 t2.start();
44 t3.start();
45 }
46 /**
47 * 执行结果
48 * 窗口2正在卖:79
49 * 窗口3正在卖:79
50 * 窗口1正在卖:-1
51 * 出现重复卖同一张票和负票,在现实中是不允许出现的
52 */
53 }
注意:执行结果出现两种问题
1.出现不同窗口卖同一张票,把票卖了两次
2.出现卖不存在的票
注意:这两种问题称为线程不安全
线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写 操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步， 否则的话就可能影响线程安全
线程同步
当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。要解决上述多线程并发访问一个资源的安全性问题:也就是解决重复票与不存在票问题，java中提供了同步机制 (synchronized)来解决
方法:
1. 同步代码块
2. 同步方法
3. 锁机制
同步代码块
同步代码块： synchronized 关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问
格式:
synchronized(同步锁){
需要同步操作的代码
}
同步锁：对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁
1. 锁对象 可以是任意类型。
2. 多个线程对象 要使用同一把锁
同步锁是谁?
对于非static方法,同步锁就是this。
对于static方法,我们使用当前方法所在类的字节码对象(类名.class)。
注意：在任何时候,最多允许一个线程拥有同步锁,谁拿到锁就进入代码块,其他的线程只能在外等着 (blocked)
1 package demosummary.threadsafety;
2
3 public class ticket02 implements runnable {
4 //定义票数
5 private int ticket = 100;
6
7 object lock = new object();
8 /**
9 * 执行卖票方法
10 */
11 @override
12
13 public void run() {
14 //卖票窗口永久开启
15 while (true) {
16 synchronized (lock) {
17 //判断票是否卖完
18 if (ticket > 0) {
19 try {
20 //三秒卖一张票
21 thread.sleep(3000);
22 } catch (interruptedexception e) {
23 e.printstacktrace();
24 }
25 string name = thread.currentthread().getname();
26 system.out.println(name + "正在卖:" + ticket--);
27 }
28 }
29 }
30 }
31 }
32
33 package demosummary.threadsafety;
34
35 public class tickettest02 {
36 public static void main(string[] args) {
37 //创建线程任务对象
38 ticket02 ticket = new ticket02();
39 //创建三个窗口对象
40 thread t1 = new thread(ticket, "窗口1");
41 thread t2 = new thread(ticket, "窗口2");
42 thread t3 = new thread(ticket, "窗口3");
43 //启用窗口来卖票
44 t1.start();
45 t2.start();
46 t3.start();
47 }
48 }
使用了同步代码块可以解决线程安全问题
同步方法
同步方法:使用synchronized修饰的方法,就叫做同步方法,保证a线程执行该方法的时候,其他线程只能在方法外等着。
格式：
public synchronized void method(){
可能会产生线程安全问题的代码
}
1 package demosummary.threadsafety;
2
3 public class ticket03 implements runnable {
4 private int ticket = 100;
5
6 /**
7 * 执行卖票方法
8 */
9 @override
10 public void run() {
11 //卖票窗口永久开启
12 while (true) {
13 sellticket();
14 }
15 }
16
17 private synchronized void sellticket() {
18 //判断票是否卖完
19 if (ticket > 0) {
20 try {
21 //三秒卖一张票
22 thread.sleep(3000);
23 } catch (interruptedexception e) {
24 e.printstacktrace();
25 }
26 //获取线程名称
27 string name = thread.currentthread().getname();
28 system.out.println(name + "正在卖:" + ticket--);
29 }
30 }
31 }
32
33
34
35 package demosummary.threadsafety;
36
37 public class tickettest03 {
38 public static void main(string[] args) {
39 //创建线程任务对象
40 ticket03 ticket = new ticket03();
41 //创建三个窗口对象
42 thread t1 = new thread(ticket, "窗口1");
43 thread t2 = new thread(ticket, "窗口2");
44 thread t3 = new thread(ticket, "窗口3");
45 //启用窗口来卖票
46 t1.start();
47 t2.start();
48 t3.start();
49 }
50 }
lock锁
java.util.concurrent.locks.lock 机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作, 同步代码块/同步方法具有的功能lock都有,除此之外更强大,更体现面向对象
lock锁也称同步锁，加锁与释放锁方法化了，如下
public void lock() :加同步锁。
public void unlock() :释放同步
1 package demosummary.threadsafety;
2
3 import java.util.concurrent.locks.lock;
4 import java.util.concurrent.locks.reentrantlock;
5
6 public class ticket04 implements runnable {
7 //定义票数
8 private int ticket = 100;
9
10 //创建锁对象
11 lock lock = new reentrantlock();
12 /**
13 * 执行卖票方法
14 */
15 @override
16 public void run() {
17 //卖票窗口永久开启
18 while (true) {
19 //给线程加锁
20 lock.lock();
21 //判断是否邮票可卖
22 if (ticket > 0) {
23 try {
24 thread.sleep(1000);
25 } catch (interruptedexception e) {
26 e.printstacktrace();
27 }
28 //获取线程当前名称
29 string name = thread.currentthread().getname();
30 system.out.println(name+"正在卖"+ticket--);
31 }
32 //释放线程锁
33 lock.unlock();
34 }
35 }
36 }
37
38 package demosummary.threadsafety;
39
40 public class tickettest04 {
41 public static void main(string[] args) {
42 //创建线程任务对象
43 ticket04 ticket = new ticket04();
44 //创建三个窗口对象
45 thread t1 = new thread(ticket, "窗口1");
46 thread t2 = new thread(ticket, "窗口2");
47 thread t3 = new thread(ticket, "窗口3");
48 //启用窗口来卖票
49 t1.start();
50 t2.start();
51 t3.start();
52 }
53 }
上一篇： java-完全解耦