Java多线程之线程安全与同步实例

1.1    线程安全与同步实例

1.1.1  购票同步对象锁

【

/*

 * 用程序模拟铁路售票系统：实现通过两个售票点发售某日某次列车的50张车票，

 * 一个售票点用一个线程表示

 */

publicclass SyncDemo {

 

         public static void main(String[] args) {

 

                   /*

                    * new SaleTicketThread("窗口1").start(); new

                    * SaleTicketThread("窗口2").start();

                    */

 

                   // 创建票对象（内部封装了卖票的方法，并且具备运行在线程中的能力）

                   Ticket tickt = new Ticket();

                   // 让多个窗口同时卖票（让线程执行指定的任务对象）

                   new Thread(tickt, "窗口1").start();

                   new Thread(tickt, "窗口2").start();

         }

 

}

 

classTicket implements Runnable {

 

         int num = 50;// 票数

         Object obj = new Object();

 

         @Override

         public void run() {

                   // 不停地卖票

                   while (true) {

                            sale();

                   }

         }

 

         /**

          * 卖票，每调用一次，卖一张票

          */

         //同步方法，其实就是同步代码块的简写方式

         public synchronized void sale() {

                   // 同步代码块，同一时间只能有一个线程进行执行里面的代码

//               synchronized (this) {// 同步锁,每个对象都可以作为同步锁进行使用(可用任何对象)

                            if (num > 0) {

                                     try {

                                               Thread.sleep(100);

                                               System.out.println(Thread.currentThread().getName()

                                                                 +"...sale..." + num--);

                                     } catch(InterruptedException e) {

                                               //TODO Auto-generated catch block

                                               e.printStackTrace();

                                     }

                            }

//               }

         }

 

}

classSaleTicketThread extends Thread {

 

         private int num = 50;

 

         public SaleTicketThread(String name) {

                   super(name);

         }

 

         @Override

         public void run() {

                   while (num > 0) {

                            System.out.println(getName()+ "......sale....." + num);

                            num--;

                   }

         }

 

}

】

1.1.2  同账户同步存钱

【

publicclass Ex1 {

 

         public static void main(String[] args){

                   Account account = newAccount();

                   new Thread(account, "小强").start();

                   new Thread(account, "小花").start();

 

         }

 

}

 

classAccount implements Runnable{

 

         private int money = 0;  //存款

        

         @Override

         public void run() {

                   //存钱三次，每次存100元，并且在读完之后显示账户的余额

                   for(int i=0;i<3;i++){

                            saveMoney(100);

                   }

         }

        

         /**

          * 存钱

          */

         public synchronized void saveMoney(intmoney){

                   this.money +=money;

                   System.out.println(Thread.currentThread().getName()+"存入100元，账户余额为"+this.money);

                   try {

                            Thread.sleep(500);

                   } catch (InterruptedExceptione) {

                            // TODOAuto-generated catch block

                            e.printStackTrace();

                   }

         }       

}

】

1.1.3  火车过山洞

【

/*

 * 有5辆火车要过山洞，但确保山洞同时只能有一辆火车通过（过山洞需要1秒），打印输出火车通过的顺序。

 * （过山洞的顺序是不可控的，只要保证同一时间只有一辆火车能通过山洞即可）

 * 提示：使用线程同步，一辆火车就是一个线程

 */

publicclass Ex2 {

 

         public static void main(String[] args){

                  

                   new Train("火车1").start();

                   new Train("火车2").start();

                   new Train("火车3").start();

                   new Train("火车4").start();

                   new Train("火车5").start();

         }

}

 

classTrain extends Thread{

        

         public Train(String name){

                   super(name);

         }

         @Override

         public void run() {

                   synchronized (Train.class) {

                            System.out.println(getName()+"过山洞.....");

                            try {

                                     Thread.sleep(1000);

                            } catch(InterruptedException e) {

                                     // TODOAuto-generated catch block

                                     e.printStackTrace();

                            }

                   }

         }

}

】

1.1.4  处理单例模式中的线程同步问题

【

在懒汉式单例模式中存在线程同步问题

处理方案：采用双重判断的形式同时解决效率和线程安全的问题

】

 

【

publicclass Demo {

 

         public static void main(String[] args){

                   new Thread() {

 

                            @Override

                            public void run() {

                                     System.out.println(Singleton3.getInstance());

                            }

 

                   }.start();

 

                   new Thread() {

 

                            @Override

                            public void run() {

                                     System.out.println(Singleton3.getInstance());

                            }

 

                   }.start();

 

         }

 

}

 

// 单例模式(饿汉式)

classSingleton {

 

         //静态字段是在类加载的时候就初始化了

         private static Singleton instance = newSingleton();

 

         // 私有化构造方法，防止外界创建对象

         private Singleton() {

 

         }

 

         public static Singleton getInstance() {

                   return instance;

         }

}

 

// 单例模式(懒汉式)

// 存在线程安全问题，可以通过双重判断加同步处理解决这里的线程安全问题

 

classSingleton2 {

 

         private static Singleton2 instance;

 

         private Singleton2() {

                   // emty

         }

 

         // 在这里，线程安全问题只会出现在第一次创建对象的时候，只要对象已经被创建完，

         // 那么就不需要再对代码进行同步处理

         // public static synchronizedSingleton2 getInstance(){//存在线程安全问题，可以通过双重判断加同步处理解决这里的线程安全问题

         public static Singleton2 getInstance(){

 

                   if (instance == null) {        //通过双重判断对象是否存在

                            synchronized(Singleton2.class) {//同步

                                     if(instance == null) {

                                               try{

                                                        Thread.sleep(100);

                                               }catch (InterruptedException e) {

                                                        //TODO Auto-generated catch block

                                                        e.printStackTrace();

                                               }

                                               instance= new Singleton2();

                                     }

                            }

 

                   }

                   return instance;

         }

}

 

/*使用静态内部类实现单例模式

 * 在类加载的时候会加载类中的成员，会初始化静态字段，将类中的成员加载到内存中(方法区)

 *

 */

classSingleton3{

        

         private Singleton3(){

                  

         }

        

         //静态代码块只会在类加载的时候被调用一次

         static{

                   System.out.println("外部类中的静态代码块......");

         }

        

         //静态内部类

         private static class Inner{

                   static Singleton3 instance =new Singleton3();

                   static{

                            System.out.println("内部类中的静态代码块.....");

                   }

         }

        

         public static Singleton3 getInstance(){

                   return Inner.instance;

         }

}

】

 

1.1.5  数字和字母的间隔输出

【

/**

 * 1.         写两个线程，一个线程打印 1~52，另一个线程打印字母A-Z打印顺序为12A34B56C……5152Z（2个数字1个字母）。

       提示：使用线程间的通信。

 */

publicclass Ex1 {

 

         public static void main(String[] args){

                   // TODO Auto-generated methodstub

                   Printer printer = newPrinter();

                   newNumberThread(printer).start();

                   newLetterThread(printer).start();

         }

 

}

//数字输出线程

classNumberThread extends Thread{

        

         private Printer printer;

         public NumberThread(Printer printer){

                   this.printer = printer;

         }

        

         @Override

         public void run() {

                   for(int i=1;i<=52;i++){

                            printer.printNum(i);

                   }

         }

}

 

//字母输出线程

classLetterThread extends Thread{

        

         private Printer printer;

        

         public LetterThread(Printer printer){

                   this.printer = printer;

         }

        

         @Override

         public void run() {

                   for(charc='A';c<='Z';c++){

                            printer.printLetter(c);

                   }

         }

}

/**

 * 打印输出类

 */

classPrinter{

        

         private boolean numOut = false;  //信号量，记录数字是否已经输出

         //输出数字

         public synchronized void printNum(intnum){

                   try {

                            if(numOut){//如果数字已经输出，就等待输出字母

                                     wait();//注意：wait、notify的调用者必须是当前同步代码块对应的同步锁

                            }

                            System.out.println(num);  //输出数字

                            //如果刚刚输出的数字是偶数的话，就唤醒字母输出线程

                            if(num % 2 == 0){

                                     numOut =true;  //标记已经输出数字

                                     notify();       //唤醒字母输出线程去输出字母

                            }

                            Thread.sleep(200);

                   } catch (InterruptedExceptione) {

                            // TODOAuto-generated catch block

                            e.printStackTrace();

                   }

                  

         }

        

         //输出字母

         public synchronized voidprintLetter(char c){

                   try {

                            if(!numOut){    //如果还没有输出数字，就等待数字输出

                                     wait();

                            }

                            System.out.println(c);   //输出字母

                            numOut = false;       //标记已经输出国字母，等待输出数字

                            notify();             //唤醒数字输出线程去输出数字

                            Thread.sleep(200);

                   } catch (InterruptedExceptione) {

                            // TODOAuto-generated catch block

                            e.printStackTrace();

                   }

                  

         }

}

】

 

1.1.6  主子线程的循环输出

【

/**

 * 子线程循环3次，接着主线程循环6次，接着又回到子线程循环3次，接着再回到主线程又循环6次，如此循环10次，请写出程序

 */

publicclass Ex2 {

 

         static boolean flag = false; // 记录子线程是否已经输出

         static Object lock = new Object();

 

         public static void main(String[] args){

                   // TODO Auto-generated methodstub

                   // 子线程

                   new Thread() {

                            @Override

                            public void run() {

                                     try {

                                               for(int i = 1; i <= 10; i++) {

                                                        synchronized(lock) {

                                                                 if(flag) {

                                                                           lock.wait();

                                                                 }

                                                                 System.out.println("~~~~~~~~~~~~~~第" + i

                                                                                    +"回合~~~~~~~~");

                                                                 for(int j = 1; j <= 3; j++) {

                                                                           System.out.println("子线程" + j);

                                                                           Thread.sleep(200);

                                                                 }

                                                                 flag= true;

                                                                 lock.notify();

                                                        }

                                               }

                                     } catch(InterruptedException e) {

                                               //TODO Auto-generated catch block

                                               e.printStackTrace();

                                     }

                            };

                   }.start();

                   // 主线程

                   for (int i = 1; i <= 10;i++) {

                            try {

                                     synchronized(lock) {

                                               if(!flag){

                                                        lock.wait();

                                               }

                                               for(int j = 1; j <= 6; j++) {

                                                        System.out.println("主线程....." + j);

                                                        Thread.sleep(200);

                                               }

                                               flag= false;

                                               lock.notify();

                                     }

                            } catch(InterruptedException e) {

                                     // TODOAuto-generated catch block

                                     e.printStackTrace();

                            }

                   }

         }

 

}

】