目录
多线程操作的问题
多个线程访问共享资源时，就会出现“脏”数据，也就是数据的错乱
下面的例子使用了多线程模拟车站售票的过程，为了让错误更明显，在线程体中使用了sleep()方法
public class Ticket implements Runnable {
private int ticket=5;//共享资源，5张票
@Override
public void run() {
//编写线程体
for (int i=0;i<100;i++){
if (ticket>0){
try {
//添加线程的休眠，提高多线程操作的"错误率"
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"卖第"+(ticket--)+"张票");
}
}
}
}
class test6{
public static void main(String[] args) {
//创建线程类对象
Ticket t=new Ticket();
//创建三个代理类线程，代理同一个线程对象，模拟三个不同的窗口
Thread t1=new Thread(t,"A窗口");
Thread t2=new Thread(t,"B窗口");
Thread t3=new Thread(t,"C窗口");
//启动线程
t1.start();
t2.start();
t3.start();
}
}在线程类中加入了休眠，使运行效果更加明显。所以看到了卖出的票数出现了0或负数的情况，如图所示
当第一个线程访问共享资源获取t对象时，执行run()方法中的代码，判断ticket>0，即5>0线程t1进入休眠状态，线程进入阻塞状态，让出CPU资源，其它两个线程假设t2“抢占”到了CPU共享资源的对象t，执行run方法中的代码，判断ticket>0，由于线程t1处于休眠状态，没有执行ticket--操作，所以t2获得的ticket值依然是5，5>0。依次类推，当ticket为1时，t1获取共享资源对象，判断ticket>0时，线程休眠，t2获取共享资源的对象，判断ticket>0时，线程休眠，这样，当休眠结束后，t1与t2都进行减1操作时，就出现了负数的情况。
线程的同步
当多个线程操作共享资源时需要使用同步来解决，即将共享资源对象“上锁”
同步的意思可以理解为完成一个功能需要N句代码，必须这N句代码一同执行完毕后，其他的线程才可以再执行这个操作，同步操作也被称作“锁对象”
要执行一次售票的功能，就必须判断ticket是否大于0，然后执行ticket--，这是卖一张票的完整的过程，所以必须这个过程中的全部代码执行完毕后，才允许其他的线程再从判断ticket是否大于0开始，所以从判断到ticket--的过程需要同步
同步分为同步代码块和同步方法
1.同步代码块，语法结构如下
synchronized(obj){
}
同步代码块synchronized(obj){}中的obj称为同步监视器，同步代码块中的同步监视器可以是任何对象，但是推荐使用共享资源作为同步监视器，在“售票”这个代码的例子中，同步监视器是当前对象this。
2.同步方法，语法结构如下
访问权限修饰符 synchronized 返回值类型 方法名称(形参列表){
}
同步方法中无需指定同步监视器，因为同步方法的监视器只能是当前对象this。
同步监视器的执行过程如下：
第一个线程访问，锁定同步监视器，执行其中代码，第二个线程访问，发现同步监视器被锁定，无法访问，第一个线程访问完毕，解锁同步监视器，第二个线程访问，发现同步监视器未锁，锁定并访问。( 同步锁定的是共享资源的对象 )
使用同步代码块实现售票
public class Ticket1 implements Runnable {
private int ticket=5;//共享5张票
@Override
public void run() {
//编写线程体
for (int i=0;i<100;i++){
synchronized (this){
if (ticket>0){
try {
//添加线程的休眠，提高多线程操作的错误率
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"卖第"+(ticket--)+"张票");
}
}
}
}
}
class TestTicket{
public static void main(String[] args) {
//创建线程类对象
Ticket1 t=new Ticket1();
//创建三个代理类线程，代理同一个线程对象t
Thread t1=new Thread(t,"A窗口");
Thread t2=new Thread(t,"B窗口");
Thread t3=new Thread(t,"C窗口");
//启动线程
t1.start();
t2.start();
t3.start();
}
}使用同步方法实现卖票
public class Ticket1 implements Runnable {
private int ticket=5;//共享5张票
@Override
public void run() {
//编写线程体
for (int i=0;i<100;i++){
//调用售票的方法
saleTicket();
}
}
public synchronized void saleTicket(){
if (ticket>0){
try {
//添加线程的休眠，提高多线程操作的"错误率"
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"卖第"+(ticket--)+"张票");
}
}
}
class TestTicket{
public static void main(String[] args) {
//创建线程类对象
Ticket1 t=new Ticket1();
//创建三个代理类线程，代理同一个线程对象t
Thread t1=new Thread(t,"A窗口");
Thread t2=new Thread(t,"B窗口");
Thread t3=new Thread(t,"C窗口");
//启动线程
t1.start();
t2.start();
t3.start();
}
}用上述两种方式对线程进行同步的操作后，程序的运行结果如下
线程的死锁
同步可以提高多个线程操作共享数据的安全性，但同时也降低了操作的效率；同步固然好，但过多的同步将导致死锁。
线程间的通信
线程间通信通常都会讲到一个叫“生产者与消费者”的问题，意思是生产者不断地生产商品，消费者不断地取走生产者生产的商品。使用程序来描述该问题就是生产者线程负责创建商品对象，并给商品的属性赋值为旺仔牌的小馒头或娃哈哈牌的矿泉水，而消费者线程则是负责获取商品对象的属性值
商品类
//商品类
public class Goods {
private String brand;
private String name;
//生产商品的同步方法
public synchronized void set(String name,String brand){
this.setBrand(brand);
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.setName(name);
System.out.println("生产者生产了"+this.getBrand()+"---"+this.getName());
}
//取走商品的同步方法
public synchronized void get(){
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("---消费者取走---"+this.getBrand()+"----"+this.getName());
}
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Goods(String brand, String name) {
this.brand = brand;
this.name = name;
}
public Goods() {
super();
}
}生产者类
//生产者线程类
public class Producer implements Runnable {
private Goods good;//共享资源
public Producer(Goods good) {
super();
this.good = good;
}
//实现run方法
@Override
public void run() {
//生产10个商品，5个旺仔小馒头，5个娃哈哈矿泉水
for (int i = 0; i < 10; i++) {
if (i % 2 == 0) {//偶数生产小馒头
//调用商品类中的生产方法
good.set("小馒头", "旺仔");
} else {//奇数生产矿泉水
//调用商品类的生产方法
good.set("矿泉水", "娃哈哈");
}
}
}
}
消费者类
//消费者类
public class Consumer implements Runnable{
private Goods good;//共享资源
public Consumer(Goods good){
super();
this.good=good;
}
//实现run方法
@Override
public void run() {
for (int i=0;i<10;i++){
//调用商品类中取走商品的方法
good.get();
}
}
}测试类
//测试类
public class Test {
public static void main(String[] args) {
//创建共享资源对象
Goods g=new Goods();
//创建生产者线程对象
Producer p=new Producer(g);
//创建消费者线程对象
Consumer c=new Consumer(g);
//创建代理线程类对象，并启动线程
new Thread(p).start();
new Thread(c).start();
}
}
运行结果
从运行效果图可以看出，重复生产商品和重复取走商品的问题明显，这时就需要用到线程间的通信来解决该问题
线程间通信的方法
线程通信的方法只能在同步方法或者同步代码块中使用，否则会抛出异常。使用线程间的通信可以解决“生产者与消费者”问题中的重复生产和重复取走的问题
只需修改商品类即可，修改后的商品类如下
public class Goods {
private String brand;
private String name;
boolean flag;
//生产商品的同步方法
public synchronized void set(String name,String brand){
if (flag){//flag==true是，有商品，所以生产者等待
try {
super.wait();//父类Object类中的wait()方法
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//notify()唤醒后从wait()之后的代码开始执行
this.setBrand(brand);
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.setName(name);
System.out.println("生产者生产了"+this.getBrand()+"---"+this.getName());
flag=true;
//通知消费者，即唤醒消费者线程
super.notify();
}
//取走商品的同步方法
public synchronized void get(){
if(!flag){//flaf==false，没有商品，消费得等待线程
try {
super.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//notify()从wait()后开始执行
//取走商品
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("---消费者取走---"+this.getBrand()+"----"+this.getName());
flag=false;//取走商品
//唤醒生产者线程
super.notify();
}
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Goods(String brand, String name) {
this.brand = brand;
this.name = name;
}
public Goods() {
super();
}
}运行结果如下
综上，数据错乱用线程同步来解决，重复生产与重复取走的问题用线程间的通信来解决
扫一扫
14万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
