java线程02

线程的同步，火车票小案例

class Ticket implements Runnable{
    private  int tick = 100;
    public void run(){
    while(true){
        if(tick>0){
System.out.println(Thread.currentThread().getName()+“售出车票，tick号为："+ tick--);
         }
       else
            break;
     }
  }
}
class  TicketDemo{
    public static void main(String[] args) {

    Ticket t = new Ticket();

    Thread t1 = new Thread(t);
    Thread t2 = new Thread(t);
    Thread t3 = new Thread(t);
     t1.setName("t1窗口");
     t2.setName("t2窗口");
     t3.setName("t3窗口");
     t1.start();
     t2.start();
     t3.start();
    }
}

：

多线程的安全问题

问题的原因：

当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错误。

解决方法：

对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。

Synchronized 同步线程方法使用

Java对于多线程的安全问题提供了专业的解决方式：

同步代码块

1. synchronized (对象）{

          // 需要被同步的代码；

    }

2. synchronized还可以放在方法声明中，表示整个方法

      为同步方法

例如：

    public synchronizedvoid show (String name){

            ….

   }

Synchronized也称之为互斥锁

在Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。

每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。

关键字synchronized 来与对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任一时刻只能由一个线程访问。

同步的局限性：导致程序的执行效率要降低

同步方法（非静态的）的锁为this。

同步方法（静态的）的锁为当前类本身。

Java中每一个对象都有一个lock,当访问某个对象的synchronized方法时，该对象就会被上锁。

一个类中有synchronized方法，如果该类的对象的该方法被访问时，那么整个对象都被锁定了，但是整个意思是其他非synchronized方法和成员变量还是可以访问的，注意区分。

因为synchronized方法会锁定对象，所以一旦有一个synchronized方法被某个线程启动了，那么对象已经被独占了，其它的synchronized方法就不能再同时独占对象了，但是普通方法和成员变量并不独占对象，所以仍然可以被调用。

单例设计模式

懒汉式

class Singleton {
	private static Singleton instance = null;
	private Singleton(){}
	public static Singleton getInstance(){
		synchronized(Singleton.class){
			if(Singleton==null){
				Singleton = new Singleton();
			}
		}		
		return instance;
	} 	
}
public class TestSingleton{
	public static void main(String[] args){
		Singleton s1=Singleton.getInstance();
		Singleton s2=Singleton.getInstance();
		System.out.println(s1==s2);
	}	
}

饿汉式

class Singleton {
	//设立静态变量，直接创建实例
	private static Singleton instance = new Singleton();
	//构造函数私有化
	private Singleton(){} 	
	public static Singleton getInstance(){		
		return instance;
	} 	
}
public class TestSingleton{
	public static void main(String[] args){
		Singleton s1=Singleton.getInstance();
		Singleton s2=Singleton.getInstance();
		System.out.println(s1==s2);
	}	}

两者的区别

两种方案的构造函数都是private私有的，类的实例为静态私有的。提供了一个public公有的静态方法给外界去访问。

    但是饿汗式每次调用的时候不用做创建，直接返回已经创建好的实例对象。这样虽然节省了时间，但是却占用了空间，实例本事为static的，会一直在内存中带着。

懒汉式则是判断，在用的时候才会加载，会影响程序的执行速度。最关键的是，在并发情况下，懒汉式是不安全的。如果两个线程，我们称之为线程1和线程2，在同一时间调用getInstance()方法，如果线程1先进入if语句块，然后线程2进行控制，那么就会有2个实例被创建。为了解决这样的并发线程的产生，我们采用synchronized解决此类问题。