当多个线程共享一份数据，执行相同任务的时候，会发生线程安全问题
当四个线程执行start()方法以后，这时候，CPU是随机的，四个线程同时抢CPU，如果thread1抢到，当他用完时间片，四个线程再一起抢时间片，这时候也不一定谁能抢到，当时间片用完的时候，需要立即释放，那么可能会停在执行任务的run方法里面，假设停在了 ticket.num = ticket.num-1;这，等thread2 ，thread3，thread4也停在这里，这样等线程再抢到时间片的时候，就会发生数据错误的情况，这样就繁盛了线程不安全的情况，这样就可以用锁解决
public class Demo1 {
public static void main(String[] args) {
Sell sell = new Sell();
//四个线程，把线程和任务绑定在一起
Thread thread1 = new Thread(sell);
Thread thread2 = new Thread(sell);
Thread thread3 = new Thread(sell);
Thread thread4 = new Thread(sell);
thread1.start();
thread2.start();
thread3.start();
thread4.start();
}
}
//四个线程共享一份数据
class Ticket{
int num = 2000;
}
//这个是卖票任务
class Sell implements Runnable{
Ticket ticket = new Ticket();
@Override
public void run() {
while (true){
ticket.num = ticket.num-1;//假设四个线程用完时间片都停在了这，当再次抢到时间片的时候，数据就会发生错误
System.out.println(Thread.currentThread().getName()+"卖票了"+"还剩"+ticket.num+"张票");
}
}
}
我们需要给加一把锁，并且必须他们四个共享的锁，这时候就能避免当thread1 线程用完时间片，但是他还是在锁里面，虽然他释放了时间片，但是必须等他再次抢到CPU的时候，全都执行完这个代码，这时候其他三个线程才有资格进来，能解决线程安全的问题
class Sell implements Runnable{
Ticket ticket = new Ticket();
@Override
public void run() {
while (true){
synchronized (ticket){
ticket.num = ticket.num-1;
System.out.println(Thread.currentThread().getName()+"卖票了"+"还剩"+ticket.num+"张票");
}
}
}
}
上锁可以上字节码文件对象，两个共有的，还有this
当我们有一份数据，两个线程和两个任务的时候，是打印和输出任务
这时候我应该打印出来 name:zhangage:19或者 name:liage:20，但是出来的时候有时候年龄和姓名不匹配也是发生了线程安全问题，当
thread1 抢到了时间片，可能是卡在了age 和name 那，等到thread2抢到时间片的时候，打印就是错误的结果，这时候我们应该给thread1 加锁，但是打印thread2 也有可能出现线程安全问题，所以打印年龄和名字还是 不匹配，这样的情况我们就应该给Syst 和Print 同时上一把锁，这样person 就是最合适的
public class Demo2 {
public static void main(String[] args) {
Person person = new Person("zhang",20);
Print print = new Print(person);
Syst syst = new Syst(person);
Thread thread1 = new Thread(print);
Thread thread2 = new Thread(syst);
thread1.start();
thread2.start();
}
}
class Person{
String name;
int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
class Print implements Runnable{
int i = 1;
Person person;
public Print(Person person) {
this.person = person;
}
@Override
public void run() {
while (true){
synchronized (person){
if(i%2==0){
person.name = "zhang";
person.age = 19;
}else{
person.name = "li";
person.age = 20;
}
i = i+1;
}
}
}
}
class Syst implements Runnable{
Person person ;
public Syst(Person person) {
this.person = person;
}
@Override
public void run() {
while (true){
synchronized (person){
System.out.println(Thread.currentThread().getName()+" " +"name:"+person.name+"age:"+person.age);
}
}
}
}
但是对于打印来说，应该是一次输入一次输出才对，所以就要写唤醒等待机制，当thread1 可以抢CPU的时候，thread2等待，暂时 失去抢CPU的能力，当thread1执行完后，他就进入了wait，thread2抢到CPU执行任务，这样就会交替进行
class Person1{
String name;
int age;
boolean flag = false;//用于执行唤醒等待的切换
public Person1(String name, int age) {
this.name = name;
this.age = age;
}
}
class Print1 implements Runnable{
int i = 1;
Person1 person;
public Print1(Person1 person) {
this.person = person;
}
@Override
public void run() {
while (true){
synchronized (person){
if(person.flag==true){
try {
person.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
if(i%2==0){
person.name = "zhang";
person.age = 19;
}else{
person.name = "li";
person.age = 20;
}
i = i+1;
person.flag = !person.flag;
person.notify();
}
}
}
}
class Syst1 implements Runnable{
Person1 person ;
public Syst1(Person1 person) {
this.person = person;
}
@Override
public void run() {
while (true){
synchronized (person){
if(person.flag==false){
try {
person.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName()+" " +"name:"+person.name+"age:"+person.age);
person.flag = !person.flag;
person.notify();
}
}
}
}
我们除了可以用唤醒等待机制意外，还可以用Lock和Condition 搭配使用，在单消费者和单生产者中，用哪个都一样，但是到了多生产者和多消费者的情况下，如果使用synchronized 会用到 notifyAll();这样会把对方全部的线程唤醒，
public class Demo5 {
public static void main(String[] args) {
Person3 person = new Person3("zhang",20);
Print3 print = new Print3(person);
Syst3 syst = new Syst3(person);
Thread thread1 = new Thread(print);
Thread thread2 = new Thread(syst);
thread1.start();
thread2.start();
}
}
class Person3{
int i = 1;
String name;
int age;
boolean flag = false;//用于执行唤醒等待的切换
Lock lock = new ReentrantLock();//相当于synchronized 他有lock()和unlock()方法
Condition preCon = lock.newCondition();//有await()等待和signal()唤醒方法
Condition sysCon = lock.newCondition();
public Person3(String name, int age) {
this.name = name;
this.age = age;
}
public void getData(){
try {
lock.lock();
while (flag==false){
try {
preCon.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName()+" " +"name:"+name+"age:"+age);
flag = !flag;
sysCon.signal();
}finally {
lock.unlock();
}
}
public void setData(){
try {
lock.lock();
while (flag==true){
try {
sysCon.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
if(i%2==0){
name = "zhang";
age = 19;
}else{
name = "li";
age = 20;
}
i = i+1;
flag = !flag;
preCon.signal();
}finally {
lock.unlock();
}
}
}
class Print3 implements Runnable{
int i = 1;
Person3 person;
public Print3(Person3 person) {
this.person = person;
}
@Override
public void run() {
while (true){
person.setData();
}
}
}
class Syst3 implements Runnable{
Person3 person ;
public Syst3(Person3 person) {
this.person = person;
}
@Override
public void run() {
while (true){
person.getData();
}
}
}