25day
package com.wang.state;
//测试是守护线程
public class TestDaemon {
public static void main(String[] args) {
God god = new God();
You you = new You();
Thread thread = new Thread(god);
thread.setDaemon(true);//默认是false表示用户线程，正常的线程都是用户线程
thread.start();//守护线程启动
new Thread(you).start();//用户线程启动
}
}
class God implements Runnable{
public void run() {
while (true){
System.out.println("上帝保佑你");
}
}
}
class You implements Runnable{
public void run() {
for (int i = 0; i < 365; i++) {
System.out.println("开心");
}
System.out.println("====goodbye，world====");
}
}
线程同步机制
并发：多个线程操控同一个对象
形成条件:队列+锁
由于同一进程中的多个进程共享同一块存储空间，在带来方便的同时，也带来了问题，为了保证数据在方法中被访问的正确性，在访问时加入锁机制（synchronized），当一个线程获得对象的排它锁，独占资源，其他线程必须等待。使用后释放锁，存在以下问题：
-
一个线程持有锁会导致其他需要此锁的线程挂起
-
在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题
-
如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置，引起性能问题
package com.wang.syn;
//不安全的取钱
public class UnSafeBank {
public static void main(String[] args) {
Account account = new Account(100,"wangyan");
Drawing you = new Drawing(account,50,"夏雨");
Drawing she = new Drawing(account,100,"夏风");
you.start();
she.start();
}
}
//账户
class Account{
int money = 0;
String name ;
public Account(int money, String name) {
this.money = money;
this.name = name;
}
}
//银行：模拟取款
class Drawing extends Thread{
Account account;//取钱
int drawingMoney;//取了多少钱
int nowMoney;//剩了多少钱
public Drawing(Account account,int drawingMoney,String name){
super(name);
this.account = account;
this.drawingMoney = drawingMoney;
}
//取钱
public void run() {
//判断有没有钱
if (account.money-drawingMoney<0){
System.out.println(Thread.currentThread().getName()+"账户余额不足");
return;
}
//sleep放大问题的发生性
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//卡内余额 = 余额 - 你取得钱数
account.money = account.money - drawingMoney;
//你手里的钱
nowMoney = nowMoney + drawingMoney;
System.out.println(account.name+"余额为"+account.money);
System.out.println(this.getName()+"取到了"+nowMoney);
}
}
package com.wang.syn;
//不安全的买票
public class UnSafeBuyTicket {
public static void main(String[] args) {
BuyTicket station = new BuyTicket();
new Thread(station,"夏雨").start();
new Thread(station,"夏风").start();
new Thread(station,"夏明").start();
}
}
class BuyTicket implements Runnable{
private int ticketNums = 10;
private boolean flag = true;//外部停止方式标志位
@Override
public void run() {
while (flag){
try {
buy();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
private void buy() throws InterruptedException {
//判断是否有票
if (ticketNums <= 0){
flag = false;
return;
}
//模拟延时
Thread.sleep(100);
//买票
System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--+"张票");
}
}
package com.wang.syn;
import java.util.ArrayList;
//线程不安全的集合
public class UnSafeList {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
for (int i = 0; i < 10000; i++) {
new Thread(()->{
list.add(Thread.currentThread().getName());
}).start();
}
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(list.size());
}
}
# day25
## 守护线程
```javapackage com.wang.state;
//测试是守护线程public class TestDaemon { public static void main(String[] args) { God god = new God(); You you = new You();
Thread thread = new Thread(god); thread.setDaemon(true);//默认是false表示用户线程，正常的线程都是用户线程
thread.start();//守护线程启动 new Thread(you).start();//用户线程启动 }}
class God implements Runnable{
@Override public void run() { while (true){ System.out.println("上帝保佑你"); } }}
class You implements Runnable{
@Override public void run() { for (int i = 0; i < 365; i++) { System.out.println("开心"); } System.out.println("====goodbye，world===="); }}```
## 线程同步机制
并发：多个线程操控同一个对象
形成条件:队列+锁
由于同一进程中的多个进程共享同一块存储空间，在带来方便的同时，也带来了问题，为了保证数据在方法中被访问的正确性，在访问时加入锁机制（synchronized），当一个线程获得对象的排它锁，独占资源，其他线程必须等待。使用后释放锁，存在以下问题：
- 一个线程持有锁会导致其他需要此锁的线程挂起- 在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题- 如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置，引起性能问题
```javapackage com.wang.syn;
//不安全的取钱public class UnSafeBank { public static void main(String[] args) { Account account = new Account(100,"wangyan"); Drawing you = new Drawing(account,50,"夏雨"); Drawing she = new Drawing(account,100,"夏风");
you.start(); she.start(); }}
//账户class Account{ int money = 0; String name ;
public Account(int money, String name) { this.money = money; this.name = name; }}//银行：模拟取款class Drawing extends Thread{
Account account;//取钱 int drawingMoney;//取了多少钱 int nowMoney;//剩了多少钱
public Drawing(Account account,int drawingMoney,String name){ super(name); this.account = account; this.drawingMoney = drawingMoney;
}
//取钱 @Override public void run() { //判断有没有钱 if (account.money-drawingMoney<0){ System.out.println(Thread.currentThread().getName()+"账户余额不足"); return; } //sleep放大问题的发生性 try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); }
//卡内余额 = 余额 - 你取得钱数 account.money = account.money - drawingMoney; //你手里的钱 nowMoney = nowMoney + drawingMoney; System.out.println(account.name+"余额为"+account.money); System.out.println(this.getName()+"取到了"+nowMoney); }}```
```javpackage com.wang.syn;
//不安全的买票public class UnSafeBuyTicket { public static void main(String[] args) { BuyTicket station = new BuyTicket(); new Thread(station,"夏雨").start(); new Thread(station,"夏风").start(); new Thread(station,"夏明").start(); }}class BuyTicket implements Runnable{
private int ticketNums = 10; private boolean flag = true;//外部停止方式标志位
@Override public void run() { while (flag){ try { buy(); } catch (InterruptedException e) { e.printStackTrace(); } } } private void buy() throws InterruptedException { //判断是否有票 if (ticketNums <= 0){ flag = false; return; } //模拟延时 Thread.sleep(100); //买票 System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--+"张票");
}}```
```javapackage com.wang.syn;
import java.util.ArrayList;
//线程不安全的集合public class UnSafeList { public static void main(String[] args) { ArrayList<String> list = new ArrayList<String>(); for (int i = 0; i < 10000; i++) { new Thread(()->{ list.add(Thread.currentThread().getName()); }).start(); } try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(list.size()); }}```
