2018-11-26

关于resultType和resultMap的区别如下：

MyBatis中在查询进行select映射的时候，返回类型可以用resultType，也可以用resultMap，resultType是直接表示返回类型的(对应着我们的model对象中的实体)，而resultMap则是对外部ResultMap的引用(提前定义了db和model之间的隐射key-->value关系)，但是resultType跟resultMap不能同时存在。
在MyBatis进行查询映射时，其实查询出来的每一个属性都是放在一个对应的Map里面的，其中键是属性名，值则是其对应的值。

• 当提供的返回类型属性是resultType时，MyBatis会将Map里面的键值对取出赋给resultType所指定的对象对应的属性。所以其实MyBatis的每一个查询映射的返回类型都是ResultMap，只是当提供的返回类型属性是resultType的时候，MyBatis对自动的给把对应的值赋给resultType所指定对象的属性。
• 当提供的返回类型是resultMap时，因为Map不能很好表示领域模型，就需要自己再进一步的把它转化为对应的对象，这常常在复杂查询中很有作用。
  例子如下：

?xml version="1.0" encoding="UTF-8"?>


    
        
        
        
        
        
        
        
    
    
    
        select id,cate_id,name,price,description,order_no,update_time 
        from goods where id = #{id}
    
    
    
        select id,cate_id,name,price,description,order_no,update_time from goods
    

单例模式

单例模式，是java中的一种设计模式，也是一种常用的软件设计模式。单例模式分三种：懒汉式单例、饿汉式单例、登记式单例三种。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，应用该模式的类一个类只有一个实例。即一个类只有一个对象实例。

单例模式：

class Single{
  private static Single instance=new Signle();
  private Single(){}
  public static Single getInstance(){
      return instance;
  }
}
class Example{
   public static void main(String[] args){
      Single s1=Single.getInstance();
     Single s2=Single.getInstance();
     System.out.println(s1==s2);
    }
}
结果为true

饿汉式单例类：

//饿汉式单例类.在类初始化时，已经自行实例化 
 public class Singleton1 {
 //私有的默认构造子
 private Singleton1() {}
  //已经自行实例化 
 private static final Singleton1 single = new Singleton1();
  //静态工厂方法 
 public static Singleton1 getInstance() {
 return single;
     }
 }

懒汉式单例类:

//懒汉式单例类.在第一次调用的时候实例化 
  public class Singleton2 {
   //私有的默认构造子
  private Singleton2() {}
    //注意，这里没有final    
  private static Singleton2 single=null;
 //静态工厂方法 
  public synchronized  static Singleton2 getInstance() {
    if (single == null) {  
       single = new Singleton2();
      }  
     return single;
    }
 }

登记式单例类:

import java.util.HashMap;
  import java.util.Map;
  //登记式单例类.
  //类似Spring里面的方法，将类名注册，下次从里面直接获取。
  public class Singleton3 {
     private static Map map = new HashMap();
      static{
          Singleton3 single = new Singleton3();
          map.put(single.getClass().getName(), single);
     }
     //保护的默认构造子
     protected Singleton3(){}
     //静态工厂方法,返还此类惟一的实例
     public static Singleton3 getInstance(String name) {
         if(name == null) {
             name = Singleton3.class.getName();
             System.out.println("name == null"+"--->name="+name);
         }
         if(map.get(name) == null) {
             try {
                 map.put(name, (Singleton3) Class.forName(name).newInstance());
            } catch (InstantiationException e) {
                 e.printStackTrace();
             } catch (IllegalAccessException e) {
                e.printStackTrace();
             } catch (ClassNotFoundException e) {
                 e.printStackTrace();
             }
         }
         return map.get(name);
     }
     //一个示意性的商业方法
     public String about() {    
         return "Hello, I am RegSingleton.";    
     }    
     public static void main(String[] args) {
         Singleton3 single3 = Singleton3.getInstance(null);
         System.out.println(single3.about());
     }
 }

单例模式的优缺点：

优点：
实例控制
1、单例模式会阻止其他对象实例化其自己的单例对象的副本，从而确保所有对象都访问唯一实例。
2、灵活性
因为类控制了实例化过程，所以类可以灵活更改实例化过程。
缺点：
1、由于单利模式中没有抽象层，因此单例类的扩展有很大的困难。
2、单例类的职责过重，在一定程度上违背了“单一职责原则”。
3、滥用单例将带来一些负面问题，如为了节省资源将数据库连接池对象设计为的单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出；如果实例化的对象长时间不被利用，系统会认为是垃圾而被回收，这将导致对象状态的丢失。

---

多线程实例：

public class Example{
    public static void main(String[] args){
        TicketWindow tw=new TicketWindow();
        new Thread(tw,"窗口1").start(); //创建线程对象并命名为窗口1,开启线程
        new Thread(tw,"窗口2").start(); //创建线程对象并命名为窗口2,开启线程
        new Thread(tw,"窗口3").start(); //创建线程对象并命名为窗口3,开启线程
        new Thread(tw,"窗口4").start(); //创建线程对象并命名为窗口4,开启线程
    }
}
class TicketWindow implements Runnable{
    private int tickets=100;
    public void run(){
        while(true){
            if(tickets>0){
                Thread th=Thread.currentThread();
                String th_name=th.getName();
                System.out.println(th_name+"正在发售第"+tickets--+"张票");
            }
        }
    }
}

运行结果：
窗口2 正在发售第100张票
窗口1 正在发售第97张票
窗口3 正在发售第99张票
窗口4 正在发售第98张票
窗口2 正在发售第95张票
窗口3 正在发售第93张票
窗口1 正在发售第94张票
。
。
。
窗口1 正在发售第1张票（最后一张）。

线程安全：

线程安全是多线程编程时的计算机程序代码中的一个概念。在拥有共享数据的多条线程并行执行的程序中，线程安全的代码会通过同步机制保证各个线程都可以正常且正确的执行，不会出现数据污染等意外情况。

类要成为线程安全的，首先必须在单线程环境中有正确的行为。如果一个类实现正确(这是说它符合规格说明的另一种方式)，那么没有一种对这个类的对象的操作序列(读或者写公共字段以及调用公共方法)可以让对象处于无效状态，观察到对象处于无效状态、或者违反类的任何不可变量、前置条件或者后置条件的情况。

此外，一个类要成为线程安全的，在被多个线程访问时，不管运行时环境执行这些线程有什么样的时序安排或者交错，它必须仍然有如上所述的正确行为，并且在调用的代码中没有任何额外的同步。其效果就是，在所有线程看来，对于线程安全对象的操作是以固定的、全局一致的顺序发生的。

正确性与线程安全性之间的关系非常类似于在描述 ACID(原子性、一致性、独立性和持久性)事务时使用的一致性与独立性之间的关系：从特定线程的角度看，由不同线程所执行的对象操作是先后(虽然顺序不定)而不是并行执行的。

Java中给我们提供是同步代码块技术来解决这个线程的安全问题：

synchronized(任意的对象（锁） )
{
    写要被同步的代码
}

例子：

//书写售票的示例
 2 class Demo implements Runnable{
 3     //定义变量记录剩余的票数
 4     int num = 100;
 5     
 6     //创建一个对象，用作同步中的锁对象
 7     Object obj = new Object();
 9     //实现run方法
10     public void run()    {       
12         //实现售票的过程
13         while( true )        {
14             //   t1  t2  t3
15             //判断当前有没有线程正在if中操作num，如果有当前线程就在这里临时等待
16             //这种思想称为线程的同步
17             //当票数小等于0的时候，就不再售票了
18             //使用同步代码块把线程要执行的任务代码可以同步起来
19             synchronized( obj )  //t1   在进入同步之前线程要先获取锁
20             /*
21                 当某个线程执行到synchronized关键字之后，这时JVM会判断当前
22                 同步上的这个对象有没有已经被其他线程获取走了，如果这时没有其他
23                 线程获取这个对象，这时就会把当前同步上的这个对象交给当前正要进入
24                 同步的这个线程。
25             */
26             {
27                 if( num > 0 )
28                 {
29                     //t0
30                     try{Thread.sleep(2);}catch( InterruptedException e ){}
31                     System.out.println(Thread.currentThread().getName()+"....."+num);
32                     num--;
33                 }
34             }//线程执行完同步之后，那么这时当前这个线程就会把锁释放掉
35         }
36     }
37 }
38 class ThreadDemo {
39     public static void main(String[] args)     {
40         //创建线程任务
41         Demo d = new Demo();
42         //创建线程对象
43         Thread t = new Thread( d );
44         Thread t2 = new Thread(d);
45         Thread t3 = new Thread(d);
46         Thread t4 = new Thread(d);
47         //开启线程
48         t.start();
49         t2.start();
50         t3.start();
51         t4.start();
52     }
53 }