1 package buyTiket;
2
3 public class SaleTicket extends Thread{
4 private String name;
5
6
7
8
9 public SaleTicket(String name) {
10 super(name);
11
12 }
13
14 private static int tickets = 100;
15 private static Object obj = new Object();
16 private static B a = new B();
17 @Override
18 public void run() {
19
20
21 while(true) {
22 /**
23 * synchronized同步代码块的锁对象可以是任意类对象(线程的实现方式是继承于Thread)
24 * 这个类对象必须是线程共享的
25 */
26
27
28 synchronized (a) {
29 if(tickets>0) {
30 try {
31 Thread.sleep(50);
32 } catch (InterruptedException e) {
33 // TODO Auto-generated catch block
34 e.printStackTrace();
35 }
36
37
38 System.out.println(this.getName()+"正在卖"+tickets--+"张票");
39 }else {
40 System.out.println("票已经售完");
41 break;
42 }
43 }
44
45
46
47 }
48 }
49 }
50 class A{
51
52
53 }
1 package buyTiket;
2
3 public class TicketTest {
4
5 public static void main(String[] args) {
6 SaleTicket st1 = new SaleTicket("窗口1");
7 SaleTicket st2 = new SaleTicket("窗口2");
8 SaleTicket st3 = new SaleTicket("窗口3");
9 SaleTicket st4 = new SaleTicket("窗口4");
10 /**
11 * 针对线程的安全性问题：我们需要使用同步(就是要加锁，共享资源只能一个人访问)锁。
12 * synchronized(锁对象){
13 * //操作共享资源的代码
14 * }
15 *
16 * 同步代码加在什么地方？
17 * 1.代码被多个线程访问
18 * 2.代码中有共享的数据
19 * 3共享数据被多条语句操作
20 */
21 st1.start();
22 st2.start();
23 st3.start();
24 st4.start();
25 }
26
27 }
package buyTiket;
public class SaleTicket2 extends Thread{
private String name;
public SaleTicket2(String name) {
super(name);
}
private static int tickets = 100;
private static Object obj = new Object();
private static A a = new A();
@Override
public void run() {
while(true) {
/**
* synchronized同步代码块的锁对象可以是任意类对象(线程的实现方式是继承于Thread)
* 这个类对象必须是线程共享的
*/
int i=0;
if(i%2==0) {
synchronized (a) {
if(tickets>0) {
try {
Thread.sleep(0);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(this.getName()+"正在卖"+tickets--+"张票");
}else {
System.out.println("票已经售完");
break;
}
}
}
else {
synchronized (a) {
if(tickets>0) {
try {
Thread.sleep(0);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(this.getName()+"正在卖"+tickets--+"张票");
}else {
System.out.println("票已经售完");
break;
}
}
}
i++;
}
}
}
class B{
}
1 package buyTiket;
2
3 public class TicketTest2 {
4
5 public static void main(String[] args) {
6 SaleTicket2 st1 = new SaleTicket2("窗口1");
7 SaleTicket2 st2 = new SaleTicket2("窗口2");
8 SaleTicket2 st3 = new SaleTicket2("窗口3");
9 SaleTicket2 st4 = new SaleTicket2("窗口4");
10 /**
11 * 针对线程的安全性问题：我们需要使用同步(就是要加锁，共享资源只能一个人访问)锁。
12 * synchronized(锁对象){
13 * //操作共享资源的代码
14 * }
15 *
16 * 同步代码加在什么地方？
17 * 1.代码被多个线程访问
18 * 2.代码中有共享的数据
19 * 3共享数据被多条语句操作
20 */
21 st1.start();
22 st2.start();
23 st3.start();
24 st4.start();
25 }
26
27 }
package buyTiket;
public class SaleTicket3 extends Thread{
private String name;
public SaleTicket3(String name) {
super(name);
}
private static int tickets = 100;
private static Object obj = new Object();
private static A a = new A();
@Override
public void run() {
while(true) {
/**
* synchronized同步代码块的锁对象可以是任意类对象(线程的实现方式是继承于Thread)
* 这个类对象必须是线程共享的
*/
int i=0;
if(i%2==0) {
//同步代码块
/**
* 这个就是当前类的类synchronizedSaleTicket3.java
*/
synchronized (SaleTicket3.class) {
if(tickets>0) {
try {
Thread.sleep(0);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"正在卖"+tickets--+"张票");
}else {
System.out.println("票已经售完");
break;
}
}
}
else {
saleTicked();
}
i++;
}
}
/**
* 静态方法的synchronized锁是当前类的类对象
*/
public synchronized static void saleTicked() {
if(tickets>0) {
try {
Thread.sleep(0);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"正在卖"+tickets--+"张票");
}else {
System.out.println("票已经售完");
}
}
}
package buyTiket;
public class TicketTest3 {
public static void main(String[] args) {
SaleTicket3 st1 = new SaleTicket3("窗口1");
SaleTicket3 st2 = new SaleTicket3("窗口2");
SaleTicket3 st3 = new SaleTicket3("窗口3");
SaleTicket3 st4 = new SaleTicket3("窗口4");
/**
* 针对线程的安全性问题：我们需要使用同步(就是要加锁，共享资源只能一个人访问)锁。
* synchronized(锁对象){
* //操作共享资源的代码
* }
*
* 同步代码加在什么地方？
* 1.代码被多个线程访问
* 2.代码中有共享的数据
* 3共享数据被多条语句操作
*/
st1.start();
st2.start();
st3.start();
st4.start();
}
}
package buyTiket;
public class SaleTicket4 implements Runnable{
// private Object obj = new Object();
private int tickets = 100;
@Override
public void run() {
while(true) {
int i=0;
if(i%2==0) {
//同步代码块
/**
* 非静态的锁就是当前的对象，它的锁是this
*/
synchronized (this) {
if(tickets>0) {
try {
Thread.sleep(0);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"正在卖"+tickets--+"张票");
}else {
System.out.println("票已经售完");
break;
}
}
}
else {
saleTicked();
}
i++;
}
}
/**
* 非静态方法的synchronized锁是当前类的类对象
*/
public synchronized void saleTicked() {
if(tickets>0) {
try {
Thread.sleep(0);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"正在卖"+tickets--+"张票");
}else {
System.out.println("票已经售完");
}
}
}
package buyTiket;
public class TicketTest4 {
public static void main(String[] args) {
SaleTicket4 st1 = new SaleTicket4();
Thread t1 = new Thread(st1,"窗口1");
SaleTicket4 st2 = new SaleTicket4();
Thread t2 = new Thread(st1,"窗口2");
SaleTicket4 st3 = new SaleTicket4();
Thread t3 = new Thread(st1,"窗口3");
SaleTicket4 st4 = new SaleTicket4();
Thread t4 = new Thread(st1,"窗口4");
t1.start();
t2.start();
t3.start();
t4.start();
}
}
浙公网安备 33010602011771号