赞
踩
例子:创建三个窗口卖票 总票数100张 使用实现Runnable接口的方式
class Window1 implements Runnable{ private int ticket=100; @Override public void run() { while (true){ if (ticket > 0) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + ":卖票,票号为" + ticket); ticket--; } else { break; } } } } public class WindowsTest1 { public static void main(String[] args) { //只创建了一个对象 Window1 window1 = new Window1(); //只是用了三个构造器 Thread t1 = new Thread(window1); Thread t2 = new Thread(window1); Thread t3 = new Thread(window1); t3.setName("窗口三"); t2.setName("窗口二"); t1.setName("窗口一"); t1.start(); t2.start(); t3.start(); } }
2. 出现问题的原因:当某个线程操作车票过程中,尚未操作完成时,其他线程参与进来操作车票。
3.如何解决:当一个线程操作票的时候,其他线程不能参与进来,知道线程a操作完ticket(票)的时候,其他线程才可以操作票(ticket)
即使线程a出现了阻塞也不能改变
4.在java中,我们通过同步机制来解决现成安全问题
方式一:同步代码块
* 关键字:synchronized(同步监视器){
* //需要被同步的代码
*
* }
* 说明: 1.需要被同步的代码指:操作共享数据的代码 ----->不能包含代码多了也不能包含代码少了
* 2.共享数据:多个线程共同操作的变量:比如ticket(票)就是共享数据
* 3.同步监视器,俗称:锁。任何一个类的对象都可以充当锁
* 要求:多个线程必须要共用同一把锁
* 补充:在实现Runnable接口创建多线程的方式中,我们可以考虑使用this充当同步监视器。
* 在继承Thread类创建多线程的方式中,慎用this充当同步监视器 。没说一定不能用 可以考虑用当前类充当同步监视器
class Window1 implements Runnable{ Object obj=new Object(); private int ticket=100; @Override public void run() { while (true){ // synchronized(obj){ //用当前对象当锁 实现runnable接口可以 继承Thread不可以 synchronized(this){//此时的this:唯一的window1的对象1 if (ticket > 0) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + ":卖票,票号为" + ticket); ticket--; } else { break; } } } } }
解决继承Thread方式的线程安全问题
/**
* 例子:创建三个窗口卖票 总票数100张 使用继承Thread类的方式
* 存在线程安全问题
*
* 使用同步代码块的方式解决继承Thread类的线程安全问题
* 继承Thread 锁对象不唯一
* 在继承Thread类创建多线程的方式中,慎用this充当同步监视器 。没说一定不能用 可以考虑用当前类充当同步监视器
* 这是一个新建的类
*/
class Window2 extends Thread{ private static Object obj=new Object(); //需要加上static 每个对象都会共享这一个静态变量 如果不加就会每个对象都获取一个 会卖300张票 private static int ticket=100; //卖票 @Override public void run() { while (true) { // synchronized (obj) { //继承Thread类的方式不可以使用this充当锁 // synchronized(this){ //用当前类充当锁 类也是对象 是唯一的类只会加载一次 synchronized(Window2.class){//(类做对象)Class clazz=Window2.class //如果票数大于0 if (ticket > 0) { try { sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + ":卖了一张票,票号为" + ticket); ticket--; } else {//如果票数为零 跳出循环 结束操作 break; } } } } } public class WindowsTest2 { public static void main(String[] args) { //创建三个卖票的窗口 Window2 t1 = new Window2(); Window2 t2 = new Window2(); Window2 t3 = new Window2(); //为线程设置名字 t1.setName("窗口一"); t2.setName("窗口二"); t3.setName("窗口三"); //开启线程开始卖票 t1.start(); t2.start(); t3.start(); } }
如果操作共享数据的代码完整声明在一个方法中,我们就将此方法声明同步的。
第一种实现runnable接口的同步方法解决
/**
* 使用同步方法解决实现runnable接口的线程安全问题
* 关于同步方法的总结:
* 1.同步方法仍然涉及到同步监视器,只是不需要我们显示的声明。
* 2.非静态的同步方法,同步监视器是:this
* 静态的同步方法它的同步监视器是当前类本身
*
*/
class Window3 implements Runnable{ private int ticket=100; @Override public void run() { while (true) { show(); } } //把卖票的方法抽取出来 private synchronized void show(){//同步监视器就是this // synchronized (this) { if (ticket > 0) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + ":卖票,票号为" + ticket); ticket--; } // } } } public class WindowsTest3 { public static void main(String[] args) { //只创建了一个对象 Window3 window3 = new Window3(); //只是用了三个构造器 Thread t1 = new Thread(window3); Thread t2 = new Thread(window3); Thread t3 = new Thread(window3); t3.setName("窗口三"); t2.setName("窗口二"); t1.setName("窗口一"); t1.start(); t2.start(); t3.start(); } }
第二种:使用继承Thread的线程安全问题解决
/** * 使用同步方法处理继承Thread类的方式中的线程安全问题 */ class Window4 extends Thread{ private static Object obj=new Object(); //需要加上static 每个对象都会共享这一个静态变量 如果不加就会每个对象都获取一个 会卖300张票 private static int ticket=100; //卖票 @Override public void run() { while (true) { show(); } } private static synchronized void show(){//同步监视器:Windows4.class // private synchronized void show(){//同步监视器t1,t2,t3 此种解决方式是错误的 //继承Thread类的方式不可以使用this充当锁 //如果票数大于0 if (ticket > 0) { try { sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + ":卖了一张票,票号为" + ticket); ticket--; } } } public class WindowsTest4 { public static void main(String[] args) { //创建三个卖票的窗口 Window4 t1 = new Window4(); Window4 t2 = new Window4(); Window4 t3 = new Window4(); //为线程设置名字 t1.setName("窗口一"); t2.setName("窗口二"); t3.setName("窗口三"); //开启线程开始卖票 t1.start(); t2.start(); t3.start(); } }
解决线程安全问题的方式三:lock锁 -----jdk5.0新增
java.util.concurrent.locks
接口 Lock
实现类 ReentrantLock
此类的构造方法接受一个可选的公平 参数。当设置为 true 时,在多个线程的争用下,这些锁倾向于将访问权授予等待时间最长的线程。
class Window implements Runnable { private int ticket = 100; //1.实例化一个lock 参数传递true会根据先后顺序执行线程 private ReentrantLock lock = new ReentrantLock(true); @Override public void run() { while (true) { //调用锁定的方法lock方法 上锁 lock.lock(); try { if (ticket > 0) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "售票 : 票号为: " + ticket); ticket--; } else { break; } } finally { //3.调用解锁的方法 lock.unlock();//解锁 } } } } public class LockTest { public static void main(String[] args) { Window window = new Window(); Thread thread1 = new Thread(window); Thread thread2 = new Thread(window); Thread thread3 = new Thread(window); thread1.setName("窗口一"); thread2.setName("窗口二"); thread3.setName("窗口三"); thread1.start(); thread2.start(); thread3.start(); } }
Copyright © 2003-2013 www.wpsshop.cn 版权所有,并保留所有权利。