java 笔记 线程5

可爱的静静

线程安全问题就是是 多个线程访问同一个 共享资源 ，如果多个线程不同步数据的话，会出现问题，可以用 synchronized（对象）同步数据维护数据。synchronized机制是给共享资源上锁，在执行之前要拿到同步对象的锁（一个对象一把锁）才可以执行同步的内容，在执行过程中不会被其他线程参与进来，同步代码在同一刻只执行一个线程，而且也同步了共享资源，只有拿到锁的线程才可以访问共享资源，这样就可以强制使得对共享资源的访问都是顺序的，线程执行完就把锁还给对象了，也就是执行同步代码前拿到锁，执行时锁锁住了，其他线程参与不进来，执行完就还给对象锁。

同步代码格式：
synchronized（对象） { 需要同步的代码； }
同步函数格式：
修饰符  synchronized void  函数名{
}
同步的前提： 
同步需要两个或者两个以上的线程。 
多个线程共享同一个数据的时候使用的是同一个锁（有多个线程 共享数据的时候要共享同一个对象 ，如果都是同步代码synchronized（对象），填的对象一样，如果有同步代码和同步函数  同步函数同步的是什么对象 同步代码synchronized（对象）就写哪个对象）
举例子：

在同步函数中。函数都会被一个对象调用，那那个对象就是this,同步韩苏护的锁就是this,在一个类里有同步代码同步函数，既然函数的对象是this,锁是this ,同步代码就写this
在静态函数中，锁是class对象,静态内存是，内存中没有本类对象，但是一定有改类对应的字节码文件对象  也就是写 本类名。Class
单例设计模式-饿汉式和懒汉式
饿汉式：
Class Single
{
private static final  single s=new single();
private Single(){}
public static Single getInstance(){
return s;
}
}


懒汉式：

1.         public static void main(String[] args) {
   
2.                 System.out.println("Hello World");
   
3.                 }
   
4. }
   
5.                 class  Single
   
6.                 {                private   static Single s=null;
   
7.                 private Single(){}
   
8.                 public static  Single getInstance(){
   
9.                                 if(s==null)
   
10.                        s=new Single();
    
11.                 return s;
    
12.                 }
    
13. 
    
14.                 }
    
15.                

复制代码

懒汉式和饿汉式有什么不同：
懒汉式是用于延迟加载
但在多线程中懒汉式会有安全性 解决方法就是同步  同步的话可以解决这个问题
但是会稍微有点低效 因为其他线程进来后先同步 ，可以用双重判断 加同步的时候锁是该类所属的字节码对象

解决后：

1.         public static void main(String[] args) {
   
2.                 System.out.println("Hello World");
   
3.                 }
   
4. }
   
5.                 class  Single
   
6.                 {
   
7.                 private   static Single s=null;
   
8.                 private Single(){}
   
9.                 public static  Single getInstance(){
   
10.                         if (s==null)
    
11.                         {
    
12.                                 synchronized(Single.class)
    
13.                                 {
    
14.                                         if(s==null)
    
15.                                                 s=new Single();
    
16.                                 }
    
17.                                 }
    
18.                         return s;
    
19.                         }

复制代码

死锁：

1. package UI;
   
2. 
   
3. import java.lang.Thread;
   
4. 
   
5. public class sport {
   
6.    public static void main(String[] args) {
   
7.       
   
8.           Ticket  a=new Ticket();
   
9.           Ticket  b=new Ticket();
   
10.          Thread b1 =new Thread(a);
    
11.          Thread b2 =new Thread(a);
    
12.          b1.start();
    
13.          try {   Thread.sleep(10);} catch (Exception e){};
    
14.          a.flag=false;
    
15.          b2.start();
    
16.          }
    
17. 
    
18.    }
    
19. class Ticket implements Runnable
    
20. {
    
21.    private int ticket=100;
    
22.    boolean flag =true;
    
23.    Object obj =new Object();
    
24.    public void run(){
    
25.       if(flag){
    
26.       while(true){
    
27.            synchronized(obj){//把这里obj 改成this
    
28.               show();//调用的show的是this的锁
    
29.       }
    
30.       }
    
31.       }
    
32.       else
    
33.          while(true)
    
34.             show();
    
35.    }
    
36.    public synchronized void show(){//this
    
37.            synchronized(obj){//这里也改为this
    
38.            if(ticket>0){
    
39.               try {   Thread.sleep(10);} catch (Exception e){};
    
40.             System.out.println(Thread.currentThread().getName()+"…sale:"+ticket--);
    
41.            }
    
42.     }
    
43.    }
    
44. }
    

复制代码

结果是 程序会挂着  执行不完
死锁：
同步中嵌套同步 同步不同
上面例子有两重锁 ，锁都是不同对象的，那就同步不了数据 ，那就是死锁了