1 package LS_进阶多线程02;
2
3 public class TestAccount {
4 public static void main(String[] args) {
5 Account ac = new Account("账号001",0);
6 AccountThread t1 = new AccountThread(ac);//创建线程
7 AccountThread t2 = new AccountThread(ac);
8 t1.setName("t1");//设置线程名
9 t2.setName("t2");
10
11 t1.start();//启动线程
12 t2.start();
13
14 }
15 }
1 package LS_进阶多线程02;
2
3 public class AccountThread extends Thread {
4 private Account ac;
5 public AccountThread(Account ac){
6 this.ac = ac;
7 }
8 @Override
9 public void run() {
10 //实现存钱的功能
11 //锁在方法上面会故扩大范围，降低效率
12 //synchronized(ac){
13 ac.add(100);
14 System.out.println(Thread.currentThread().getName()+"存钱，余额"+ac.getMoney());
15 //}
16 }
17 }
1 package LS_进阶多线程02;
2
3 public class Account {
4 String id;
5 int money;
6 Object o = new Object();
7 public Account(String id,int money){
8 super();
9 this.id = id;
10 this.money = money;
11 }
12
13 public String getId() {
14 return id;
15 }
16
17 public void setId(String id) {
18 this.id = id;
19 }
20
21 public int getMoney() {
22 return money;
23 }
24
25 public void setMoney(int money) {
26 this.money = money;
27 }
28 //存钱
29 public void add(int money){
30 // //获取原本的余额
31 // int before = this.money;
32 // //加上存进去的钱
33 // int after = before+money;
34 //
35 // //模拟网络延迟
36 // try {
37 // Thread.sleep(1000);
38 // } catch (InterruptedException e) {
39 // e.printStackTrace();
40 // }
41 // //将总的余额设置成形成的余额
42 // this.setMoney(after);
43 //synchronized(){}
44 //同步锁：synchronized的互斥机制
45 //()里面放的是：同步的线程的共享对象，id也可以
46 //synchronized也可以对方法和类实现锁
47
48 //局部变量无法实现锁定
49 Object o = new Object();
50 //synchronized (this){
51 //synchronized (o){
52 synchronized (id){
53 //获取原本的余额
54 int before = this.money;
55 //加上存进去的钱
56 int after = before+money;
57
58 //模拟网络延迟
59 try {
60 Thread.sleep(1000);
61 } catch (InterruptedException e) {
62 e.printStackTrace();
63 }
64 //将总的余额设置成形成的余额
65 this.setMoney(after);
66 }
67 }
68 }
1 package LS_进阶多线程02; 2 3 //死锁的实现 4 5 public class TestDeadLock { 6 public static void main(String[] args) { 7 8 Object o1 = new Object(); 9 Object o2 = new Object(); 10 Thread t1 = new Thread(new Thread01(o1,o2)); 11 Thread t2 = new Thread(new Thread02(o1,o2)); 12 13 t1.start(); 14 t2.start(); 15 16 } 17 } 18 19 20 class Thread01 implements Runnable { 21 Object o1; 22 Object o2; 23 24 public Thread01(Object o1, Object o2) { 25 this.o1 = o1; 26 this.o2 = o2; 27 } 28 29 @Override 30 public void run() { 31 synchronized (o1) { 32 try { 33 Thread.sleep(1000); 34 } catch (InterruptedException e) { 35 e.printStackTrace(); 36 } 37 synchronized (o2) { 38 39 } 40 } 41 } 42 } 43 44 45 class Thread02 implements Runnable { 46 47 Object o1; 48 Object o2; 49 public Thread02(Object o1, Object o2) { 50 this.o1 = o1; 51 this.o2 = o2; 52 } 53 54 @Override 55 public void run() { 56 synchronized (o2) { 57 try { 58 Thread.sleep(1000); 59 } catch (InterruptedException e) { 60 e.printStackTrace(); 61 } 62 synchronized (o1) { 63 64 } 65 } 66 } 67 }
1 package LS_进阶多线程02;
2
3 //死锁的实现
4
5 public class TestDeadLock {
6 public static void main(String[] args) {
7 Object o1 = new Object();
8 Object o2 = new Object();
9 Thread t1 = new Thread(new Thread01(o1,o2));
10 Thread t2 = new Thread(new Thread01(o1,o2));
11
12 t1.start();
13 t2.start();
14
15 }
16 }
17
18
19 class Thread01 implements Runnable {
20 Object o1;
21 Object o2;
22
23 public Thread01(Object o1, Object o2) {
24 this.o1 = o1;
25 this.o2 = o2;
26 }
27
28 @Override
29 public void run() {
30 synchronized (o1) {
31 try {
32 Thread.sleep(1000);
33 } catch (InterruptedException e) {
34 e.printStackTrace();
35 }
36 synchronized (o2) {
37 }
38 }
39 }
40 }
41 class Thread02 implements Runnable {
42 Object o1;
43 Object o2;
44
45 public Thread02(Object o1, Object o2) {
46 this.o1 = o1;
47 this.o2 = o2;
48 }
49
50 @Override
51 public void run() {
52 synchronized (o2) {
53 try {
54 Thread.sleep(1000);
55 } catch (InterruptedException e) {
56 e.printStackTrace();
57 }
58 synchronized (o1) {
59
60 }
61 }
62 }
63
1 package LS_进阶多线程02;
2
3 //t2要不要等t1执行完，才能执行--->不要
4 //对象锁锁的对象，100个对象有100把锁
5 //类锁锁的是类，100个对象还是一把锁
6 public class TestLock {
7 public static void main(String[] args) {
8 MyClass mc1 = new MyClass();
9 MyClass mc2 = new MyClass();
10
11 Thread t1 = new Thread(new MyThread(mc1));
12 Thread t2 = new Thread(new MyThread(mc1));
13
14 t1.setName("t1");
15 t2.setName("t2");
16
17
18 t1.start();
19
20 try {
21 Thread.sleep(1000);//确保t1先执行
22 } catch (InterruptedException e) {
23 e.printStackTrace();
24 }
25
26 t2.start();
27 }
28 }
29
30 class MyThread implements Runnable{
31 private MyClass mc;
32 public MyThread(MyClass mc){
33 this.mc = mc;
34 }
35 @Override
36 public void run() {
37 if(Thread.currentThread().getName()=="t1"){
38 mc.test01();
39 }
40 if(Thread.currentThread().getName()=="t2"){
41 mc.test02();
42 }
43 }
44 }
45
46
47 class MyClass{
48 //public void test01(){
49 public synchronized void test01(){ //这个可以实现t1执行完，t2执行
50 System.out.println("test01.begin");
51
52 try {
53 Thread.sleep(1000*5);
54 } catch (InterruptedException e) {
55 e.printStackTrace();
56 }
57 System.out.println("test01.over");
58 }
59
60 public synchronized void test02(){//如果没有synchronized，那么无法实现t1先完成
61 System.out.println("test02.begin");
62 System.out.println("test02.over");
63 }
64 }