Java多线程编程(同步、死锁、生产消费者问题)

package com.xbhog;
class MyThread implements Runnable {// 定义线程执行类
    private int ticket = 3;// 总票数为6张
    @Override
    public void run() {
        while (true) { // 持续卖票
            if (this.ticket > 0) { // 还有剩余票
                try {
                    Thread.sleep(100); // 模拟网络延迟
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //获取当前线程的名字
                System.out.println(Thread.currentThread().getName() +
                        "卖票，ticket = " + this.ticket--);
            } else {
                System.out.println("***** 票已经卖光了 *****");
                break;// 跳出循环
            }
        }
    }
}
public class Java多线程核心 {
    public static void main(String[] args) throws Exception {
        MyThread mt = new MyThread();
        new Thread(mt, "售票员A").start(); // 开启卖票线程
        new Thread(mt, "售票员B").start(); // 开启卖票线程
        new Thread(mt, "售票员C").start(); // 开启卖票线程
    }
}

package com.xbhog.死锁;

class Book {
    public synchronized void tell(Painting paint) {  // 同步方法
        System.out.println("张三对李四说：把你的画给我，我就给你书，不给画不给书！");
        paint.get();
    }
    public synchronized void get() {      // 同步方法
        System.out.println("张三得到了李四的画开始认真欣赏。");
    }
}
class Painting {
    public synchronized void tell(Book book) {    // 同步方法
        System.out.println("李四对张三说：把你的书给我，我就给你画，不给书不给画！");
        book.get();
    }
    public synchronized void get() {      // 同步方法
        System.out.println("李四得到了张三的书开始认真阅读。");
    }
}
public class DeadLock implements Runnable{
    private Book book = new Book();
    private Painting paint = new Painting();
    public DeadLock() {
        new Thread(this).start();
        book.tell(paint);
    }
    @Override
    public void run() {
        paint.tell(book);
    }
    public static void main(String[] args) {
        new DeadLock() ;
    }
}

class Message {
 private String title ;       // 保存信息的标题
 private String content ;       // 保存信息的内容
 public synchronized void set(String title, String content) {
  this.title = title;
  try {
   Thread.sleep(200);
  } catch (InterruptedException e) {
   e.printStackTrace();
  }
  this.content = content;
 }
 public synchronized String get() {
  try {
   Thread.sleep(100);
  } catch (InterruptedException e) {
   e.printStackTrace();
  }
  return this.title + " --> " + this.content;
 }
 // setter、getter略
}
class Producer implements Runnable {     // 定义生产者
 private Message msg = null ;
 public Producer(Message msg) {
  this.msg = msg ;
 }
 @Override
 public void run() {
  for (int x = 0; x < 50; x++) {    // 生产50次数据
   if (x % 2 == 0) {
    this.msg.set("xbhog","22") ; // 设置属性
   } else {
    this.msg.set("xbhog","www.cnblog.cn/xbhog") ; // 设置属性
   }
  }
 }
}
class Consumer implements Runnable {     // 定义消费者
 private Message msg = null ;
 public Consumer (Message msg) {
  this.msg = msg ;
 }
 @Override
 public void run() {
  for (int x = 0; x < 50; x++) {    // 取走50次数据
   System.out.println(this.msg.get());   // 取得属性
  }
 }
}
public class ThreadDemo {
 public static void main(String[] args) throws Exception {
  Message msg = new Message() ;     // 定义Message对象，用于保存和取出数据
  new Thread(new Producer(msg)).start() ;  // 启动生产者线程
  new Thread(new Consumer(msg)).start() ;  // 取得消费者线程
 }
}

class Message {
 private String title ;
 private String content ;
 private boolean flag = true;      // 表示生产或消费的形式
 // flag = true：允许生产，但是不允许消费
 // flag = false：允许消费，不允许生产
 public synchronized void set(String title,String content) {
  if (this.flag == false) {      // 无法进行生产，等待被消费
   try {
    super.wait();
   } catch (InterruptedException e) {
    e.printStackTrace();
   } 
  }
  this.title = title ;
  try {
   Thread.sleep(100);
  } catch (InterruptedException e) {
   e.printStackTrace();
  }
  this.content = content ;
  this.flag = false ;        // 已经生产过了
  super.notify();         // 唤醒等待的线程
 }
 public synchronized String get() {
  if (this.flag == true) {      // 还未生产，需要等待
   try {
    super.wait();
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
  }
  try {
   Thread.sleep(10);
  } catch (InterruptedException e) {
   e.printStackTrace();
  }
  try {
   return this.title + "  -  " + this.content ;
  } finally {          // 不管如何都要执行
   this.flag = true ;        // 继续生产
   super.notify();         // 唤醒等待线程
  }
 }
}