1: 同步方法
1 package Thread; 2 3 /** 4 * author liulei 5 * data 6 * since 1.8 7 * version 1.0 8 * Description 方法锁 9 */ 10 //不安全的买票 11 public class Test17 { 12 public static void main(String[] args) {//出现同一张票被多次购买 13 BuyTicket t = new BuyTicket(); 14 new Thread(t,"a").start(); 15 new Thread(t,"b").start(); 16 new Thread(t,"c").start(); 17 } 18 } 19 class BuyTicket implements Runnable{ 20 private int ticketNum = 10; 21 Boolean flag =true;//外部停止方式 22 @Override 23 public void run() { 24 try { 25 Thread.sleep(10); 26 } catch (InterruptedException e) { 27 e.printStackTrace(); 28 } 29 while (flag){ 30 try { 31 buy(); 32 } catch (InterruptedException e) { 33 e.printStackTrace(); 34 } 35 } 36 } 37 private synchronized void buy() throws InterruptedException {//每个对象对应一把锁，这把锁就是this, 38 if(ticketNum <= 0){ 39 flag = false; 40 return; 41 } 42 Thread.sleep(100); 43 System.out.println(Thread.currentThread().getName() + "拿到" + ticketNum--); 44 45 } 46 47 48 }
2: 同步块
1 package Thread; 2 3 /** 4 * author liulei 5 * data 6 * since 1.8 7 * version 1.0 8 * Description 同步块 9 */ 10 public class Test18 { 11 public static void main(String[] args) { 12 Account account = new Account(100,"结婚基金"); 13 Drawing you = new Drawing(account, 50, "你"); 14 Drawing girl = new Drawing(account, 100, "她"); 15 you.start(); 16 girl.start();//可能导致多取钱 17 } 18 } 19 class Account{ 20 int money;//余额 21 String name;//卡名 22 23 public Account(int money, String name) { 24 this.money = money; 25 this.name = name; 26 } 27 } 28 //银行，模拟取款 29 class Drawing extends Thread{ 30 Account account;//账户 31 //取了多少钱 32 int drawingMoney; 33 //现在手里有多少钱 34 int nowmoney; 35 36 37 public Drawing(Account account, int drawingMoney, String name) { 38 super(name); 39 this.account = account; 40 this.drawingMoney = drawingMoney; 41 42 } 43 44 @Override 45 public void run() {//使用代码块加锁还不是在放上上是因为this是Drawing,而真正需要锁的对象是account 46 synchronized (account){ 47 if(account.money-drawingMoney<0){ 48 System.out.println(Thread.currentThread().getName() + "钱不够取不了"); 49 return; 50 } 51 account.money -=drawingMoney; 52 nowmoney += drawingMoney; 53 System.out.println(account.name + "余额为" + account.money); 54 System.out.println(this.getName()+"手里的钱" + nowmoney); 55 } 56 try { 57 Thread.sleep(100); 58 } catch (InterruptedException e) { 59 e.printStackTrace(); 60 } 61 } 62 }
1 package Thread; 2 3 import java.util.ArrayList; 4 import java.util.List; 5 6 /** 7 * author liulei 8 * data 5.25 9 * since 1.8 10 * version 1.0 11 * Description 不安全线程3 12 */ 13 public class Test19 { 14 public static void main(String[] args) throws InterruptedException { 15 List<String> list = new ArrayList<String>(); 16 for (int i = 0; i < 10000; i++) { 17 synchronized (list){//对多个线程共同处理的list进行加锁 18 new Thread(()->{ 19 list.add(Thread.currentThread().getName()); 20 }).start(); 21 } 22 } 23 Thread.sleep(100); 24 System.out.println(list.size());//总数可能少于10000 25 } 26 27 }
package Thread; import java.util.ArrayList; import java.util.List; import java.util.concurrent.CopyOnWriteArrayList; /** * author liulei * data * since 1.8 * version 1.0 * Description 测试JUC安全类型的集合 */ public class Test20 { public static void main(String[] args) throws InterruptedException { CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();//本身是对list的升级，已经保证了线程安全性，不需要加锁 for (int i = 0; i < 10000; i++) { new Thread(()->{ list.add(Thread.currentThread().getName()); }).start(); } Thread.sleep(100); System.out.println(list.size());//总数可能少于10000 } }
深入理解使用synchronized同步方法和同步代码块的区别
同步方法对于当前对象this是要多个线程工作操作的对象时可以用同步方法，当然可以用代码块替代。否则要用同步代码块，把进行增删改的对象作为锁。
方式一：同步代码块： synchronized(同步监视器){ //操作共享数据的代码 } 注：1.同步监视器：俗称锁，任何一个类的对象都可以才充当锁。要想保证线程的安全，必须要求所有的线程共用同一把锁！ 2.使用实现Runnable接口的方式创建多线程的话，同步代码块中的锁，可以考虑是this。如果使用继承Thread类的方式，慎用this! 3.共享数据：多个线程需要共同操作的变量。 明确哪部分是操作共享数据的代码。 方式二：同步方法：将操作共享数据的方法声明为synchronized。 比如：public synchronized void show(){ //操作共享数据的代码} 注：1.对于非静态的方法而言，使用同步的话，默认锁为：this。如果使用在继承的方式实现多线程的话，慎用！ 2.对于静态的方法，如果使用同步，默认的锁为：当前类本身。以单例的懒汉式为例。 Class clazz = Singleton.class 总结：释放锁:wait(); 不释放锁： sleep() yield() suspend() (过时，可能导致死锁)
3: 死锁
1 package Thread; 2 3 /** 4 * author liulei 5 * data 5.25 6 * since 1.8 7 * version 1.0 8 * Description 死锁：多个线程互相抱着对方需要的资源，形成僵持 9 */ 10 public class Test21 { 11 public static void main(String[] args) { 12 Makeup makeup = new Makeup(0,"李雷"); 13 Makeup makeup1 = new Makeup(1,"韩梅梅"); 14 makeup.start(); 15 makeup1.start(); 16 } 17 } 18 //口红 19 class Lipstick{ 20 21 } 22 //镜子 23 class Mirror{ 24 25 } 26 class Makeup extends Thread{ 27 //需要的资源只有一份，用static来保证只有一份 28 static Lipstick lipstick = new Lipstick(); 29 static Mirror mirror = new Mirror(); 30 int choice;//选择 31 String girlName;//使用 32 33 public Makeup(int choice, String girlName) { 34 this.choice = choice; 35 this.girlName = girlName; 36 } 37 38 @Override 39 public void run() { 40 try { 41 makeup(); 42 } catch (InterruptedException e) { 43 e.printStackTrace(); 44 } 45 } 46 private void makeup() throws InterruptedException { 47 if(choice == 0){//李雷获得口红的锁，韩梅梅获得镜子的锁，但李雷韩梅梅希望获取对方的锁，但又不愿意释放自己的锁，形成死锁 48 synchronized (lipstick){ 49 System.out.println(this.girlName + "获得口红的锁"); 50 Thread.sleep(100); 51 synchronized (mirror){ 52 System.out.println(this.girlName + "获得镜子的锁"); 53 } 54 } 55 56 } 57 if(choice == 1){ 58 synchronized (mirror){ 59 System.out.println(this.girlName + "获得镜子的锁"); 60 Thread.sleep(100); 61 synchronized (lipstick){ 62 System.out.println(this.girlName + "获得口红的锁"); 63 } 64 } 65 66 } 67 } 68 }
解决死锁
package Thread; /** * author liulei * data 5.25 * since 1.8 * version 1.0 * Description 解决死锁的一个方法就是用完自己的锁后释放 */ public class Test22 { public static void main(String[] args) { Makeup1 makeup = new Makeup1(0,"李雷"); Makeup1 makeup1 = new Makeup1(1,"韩梅梅"); makeup.start(); makeup1.start(); } } //口红 class Lipstick1{ } //镜子 class Mirror1{ } class Makeup1 extends Thread{ //需要的资源只有一份，用static来保证只有一份 static Lipstick lipstick = new Lipstick(); static Mirror mirror = new Mirror(); int choice;//选择 String girlName;//使用 public Makeup1(int choice, String girlName) { this.choice = choice; this.girlName = girlName; } @Override public void run() { try { makeup(); } catch (InterruptedException e) { e.printStackTrace(); } } private void makeup() throws InterruptedException { if(choice == 0){//李雷获得口红的锁，韩梅梅获得镜子的锁，但李雷韩梅梅希望获取对方的锁，但又不愿意释放自己的锁，形成死锁 synchronized (lipstick){ System.out.println(this.girlName + "获得口红的锁"); Thread.sleep(100); } synchronized (mirror){ System.out.println(this.girlName + "获得镜子的锁"); } } if(choice == 1){ synchronized (mirror){ System.out.println(this.girlName + "获得镜子的锁"); Thread.sleep(100); } synchronized (lipstick){ System.out.println(this.girlName + "获得口红的锁"); } } } }
4: Lock
1 package Thread; 2 3 import java.util.concurrent.locks.ReentrantLock; 4 5 /** 6 * author liulei 7 * data 5.25 8 * since 1.8 9 * version 1.0 10 * Description lock锁 11 */ 12 public class Test23 { 13 public static void main(String[] args) { 14 TestLock testLock = new TestLock(); 15 new Thread(testLock).start(); 16 } 17 } 18 class TestLock implements Runnable{ 19 int ticketNum = 10; 20 private final ReentrantLock lock = new ReentrantLock(); 21 @Override 22 public void run() { 23 while (true){ 24 try{ 25 lock.lock();//加锁 26 if(ticketNum > 0){ 27 try { 28 Thread.sleep(1000); 29 } catch (InterruptedException e) { 30 e.printStackTrace(); 31 } 32 System.out.println(ticketNum--); 33 }else{ 34 break; 35 } 36 }finally { 37 lock.unlock();//解锁 38 } 39 } 40 } 41 }
5: 线程通信
1 package Thread; 2 3 /** 4 * author liulei 5 * data 5.25 6 * since 1.8 7 * version 1.0 8 * Description 线程通信，生产者消费者（管程） 9 */ 10 public class Test24 { 11 public static void main(String[] args) { 12 SynContainer synContainer = new SynContainer(); 13 new consumer(synContainer).start(); 14 new product(synContainer).start(); 15 16 } 17 } 18 class product extends Thread{ 19 SynContainer synContainer; 20 21 public product(SynContainer synContainer) { 22 this.synContainer = synContainer; 23 } 24 25 @Override 26 public void run() { 27 for (int i = 0; i < 100; i++) { 28 29 try { 30 synContainer.push(new Chicken(i)); 31 } catch (InterruptedException e) { 32 e.printStackTrace(); 33 } 34 System.out.println("生产者生产第" + (i+1) + "只鸡"); 35 } 36 } 37 } 38 class consumer extends Thread{ 39 SynContainer synContainer; 40 41 public consumer(SynContainer synContainer) { 42 this.synContainer = synContainer; 43 } 44 45 @Override 46 public void run() { 47 for (int i = 0; i < 100; i++) { 48 try { 49 System.out.println("消费者消费了第" + (synContainer.pop().id+1) + "只鸡"); 50 } catch (InterruptedException e) { 51 e.printStackTrace(); 52 } 53 } 54 try { 55 synContainer.pop(); 56 } catch (InterruptedException e) { 57 e.printStackTrace(); 58 } 59 } 60 } 61 class Chicken{ 62 int id; 63 64 public Chicken(int id) { 65 this.id = id; 66 } 67 } 68 class SynContainer{ 69 Chicken[] chickens = new Chicken[10];//容器大小 70 int count = 0;//容器计数器 71 //生产者放入产品 72 public synchronized void push(Chicken chicken) throws InterruptedException { 73 if(count == chickens.length){ 74 //通知消费者消费，生产等待 75 wait(); 76 } 77 chickens[count] = chicken; 78 count++; 79 //可以通知消费者消费了 80 notify(); 81 } 82 //消费者消费产品 83 public synchronized Chicken pop() throws InterruptedException { 84 //判断能否消费 85 if(count == 0){ 86 //等待生产者生产，消费者等待 87 wait(); 88 } 89 //可以消费了 90 count--; 91 Chicken chicken = chickens[count]; 92 //吃完了，通知生产者生产 93 notify(); 94 return chicken; 95 } 96 }
1 package Thread; 2 3 /** 4 * author liulei 5 * data 5.25 6 * since 1.8 7 * version 1.0 8 * Description 演员和观众（信号量） 9 */ 10 public class Test25 { 11 public static void main(String[] args) { 12 TV tv = new TV(); 13 new Player(tv).start(); 14 new Watcher(tv).start(); 15 } 16 } 17 //生产者-->演员 18 class Player extends Thread{ 19 TV tv; 20 21 public Player(TV tv) { 22 this.tv = tv; 23 } 24 25 @Override 26 public void run() { 27 for (int i = 0; i < 10; i++) { 28 if(i%2 == 0){ 29 try { 30 this.tv.play("梦想中国节目"); 31 } catch (InterruptedException e) { 32 e.printStackTrace(); 33 } 34 }else{ 35 try { 36 this.tv.play("天天向上节目"); 37 } catch (InterruptedException e) { 38 e.printStackTrace(); 39 } 40 } 41 } 42 } 43 } 44 //消费者-->观众 45 class Watcher extends Thread{ 46 TV tv; 47 48 public Watcher(TV tv) { 49 this.tv = tv; 50 } 51 52 @Override 53 public void run() { 54 try { 55 for (int i = 0; i < 10; i++) { 56 tv.watch(); 57 } 58 } catch (InterruptedException e) { 59 e.printStackTrace(); 60 }; 61 } 62 } 63 //产品-->节目 64 class TV{ 65 //演员表演，观众等待 66 //观众观看，演员等待 67 String voice; 68 boolean flag = true;//没有节目了 69 //表演 70 public synchronized void play(String voice) throws InterruptedException { 71 if(!flag){ 72 wait(); 73 } 74 System.out.println("演员表演了" + voice); 75 //通知观众观看 76 this.notifyAll();//通知观看 77 this.voice = voice; 78 this.flag = false; 79 } 80 //观看 81 public synchronized void watch() throws InterruptedException { 82 if(flag){ 83 wait(); 84 } 85 System.out.println("观众观看了" + voice); 86 //通知演员表演 87 this.notifyAll(); 88 this.flag = true; 89 } 90 91 }
6: 线程池
1 package Thread; 2 3 import java.util.concurrent.ExecutorService; 4 import java.util.concurrent.Executors; 5 6 /** 7 * author liulei 8 * data 9 * since 1.8 10 * version 1.0 11 * Description 12 */ 13 public class Test26 { 14 public static void main(String[] args) { 15 //创建服务，创建线程池 16 ExecutorService service = Executors.newFixedThreadPool(10); 17 service.execute(new MyThread());//执行 18 service.execute(new MyThread()); 19 service.execute(new MyThread()); 20 service.execute(new MyThread()); 21 service.shutdown();//关闭链接 22 } 23 } 24 class MyThread implements Runnable{ 25 @Override 26 public void run() { 27 for (int i = 0; i < 10; i++) { 28 System.out.println(Thread.currentThread().getName()); 29 } 30 } 31 }
线程池狂神说的比较简单，推荐自己再多看一些内容