分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net 
 
- 方法1：类型.class，例如：String.class
 - 方法2：对象.getClass()，例如："hello".getClass()
 - 方法3：Class.forName()，例如：Class.forName("java.lang.String")

Synchronized  ：锁住的是对象，出现synchronized表示随后的代码块要用到共享数据了，要锁住了。
一、3种形式。
1、synchronized(obj)：可以任意指定对象.

2、synchronized(this)：当前对象：当一个类加到内存时，常量池有一个地址直接指向当前正在执行的对象.
 3、public synchronized void run()：当前对象（this），这是实例方法，每一方法里存着一个This.方法
对象：可以是普通类 public class Test {}, 也可以是干活线程类 ,只要是new 类名 的所有对象。
     **所以synchronized(this){} 和synchronized 方法差不多，反正是锁当前对象。

  
二、对于锁类其实也一样，因为一个类入内存后，还是java.lang.Class 的类对象。所以还是锁对象。
三、锁的数据：一个类成员数据：对象实例变量，类变量
  1、object instance variables:对象实例变量，存在堆中。
  2、class variables：类变量，存在method area。
    如果您正在写一个变量，这个变量有可能随后被另一个线程读，
     或您正在读一个变量，这个变量有可能随后被另一个线程写，
这时你必须用到变量的地方放一个synchronized,
四、例子
1、简单需求
例如：银行个人账户（对象）：卡号，余额
  如果一个小店主，顾客很多，如果都用微信付款的话，有可能同一时刻访问店主的银行个人账户的问题。

当一个顾客对店主的账号余额进行加减时，锁住账号，退出后，另一个顾客才能继续付钱，
顾客是看不见这些过程，只管提交就行，银行应该是相应的服务软件接收用户的请求。
2、代码说明
             1>有4个线程，main()主线程，3个顾客子线程
                 因为是几个顾客有可能同时付款，所以需要线程。
            2>一个店主银行个人账户的对象（对象里面有共享资源，余额）
银行个人账户的对象（peraccount）对应一个monitor。
3>执行步骤（只取其中一个结果分析）
第一：main线程执行到threads[0].start(),threads[1].start(),threads[2].start();
即3个线程入就绪对象，这是main代码执行完，cpu空
第二：调度程序选择threads[0]进入cpu。
第三：
（一）当jvm行到synchronized peraccount 这一句时，表示peraccount 对象里面有共享数据,
去取一把钥匙，看人家是否已经锁住共享数据了.去哪里取呢？monitor大楼。
（二）这时cpu空,调度程序安排thread[2]入cpu,thread[0]去monitor大楼取钥匙去了
两个过程同时执行。

（三）当jvm 执行到threads[2]到synchronized peraccount 时，又该去peraccount monitor大楼取钥匙了。
同时cpu还是空。
     

（四）调度程序安排thread[1]入cpu执行，在monitor大厅等待，
            同时cpu空，这时，thread[0]已经占用特殊房间，表示取得钥匙，获得一把锁，锁住后面的代码。

1》调度程序安排thread[0]进入Cpu,因为后面的代码已经被thread[0]锁住，所以一直占cpu执行完。
cpu空，同时特殊房间空，thread[1]和thread[2]竞争，thread[1]进入特殊房间，获得锁。
2》thread[1]占用特殊房间，表示取得钥匙，获得一把锁，锁住后面的代码。所以一直占cpu执行完,
cpu空，同时特殊房间空，thread[2]进入特殊房间。
3》thread[2]已经占用特殊房间，表示取得钥匙，获得一把锁，锁住后面的代码。所以一直占cpu执行完,cpu空
整个过程完
   3、图形
               
             
                 
                


    4、代码
           
package concurrency;


/**
 * 银行个人账户，共享数据， 
 * cardnumber，balance
 * 一个卡号，多人可以对余额进行修改。
 * 
 */
class Account {
 private  String  cardnumber;//卡号
 private float balance; //余额 


public Account(String cardnumber, float balance) {
this.cardnumber = cardnumber;
this.balance = balance;
}


// 存钱
public void deposit(float sum) {
balance= balance+sum;
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}

   //得到当前钱数。
public float getBalance() {
return balance;
}
}


/**
 * PayToAccount 现在是静态类
 * 可以new 多个对象，表示多人用微信付款
 * 每一支付的人和店主的个人账号相连
 */
public class PayToAccount  implements Runnable {
private Account peraccount; //表示和店主个人账号对象相连接
private float sum;


public PayToAccount(Account peraccount,float sum) {
this.peraccount = peraccount;
this.sum=sum;
}

public void run() {
System.out.println(Thread.currentThread().getName()+" run()");
synchronized (peraccount) {//到这里表示要锁住店主的个人账号对象了，后面涉及对同一对象进行操作。
System.out.println(Thread.currentThread().getName()+" 取得钥匙");
peraccount.deposit(this.sum);
System.out.println(Thread.currentThread().getName() + ":"
+peraccount.getBalance());
}
}
/**客户微信软件---扫一下，哪么微信软件应该提取了店主的个人账号，点支付之后，应该是执行PayToAccount的run操作。
 * 下面是模拟顾客扫微信的功能，只用了固定的3个顾客，但是现实顾客数无法确定。
 */
public static void main(String[] args) {
//店主墙上的微信号（也就是店主的银行个人账号）
Account account = new Account("yang", 50.0f);//


//相当客户扫一扫：把自己和店主的银行个人账号相连,
//账号，存的钱数。
PayToAccount buyer1 = new PayToAccount(account,50.0f);
PayToAccount buyer2 = new PayToAccount(account,125.0f);
PayToAccount buyer3 = new PayToAccount(account,310.0f);

/**
* 相当3个客户都点了支付按钮，付钱，
* 涉及同时对一个账号进行操作，
* 建立三个新的驱动线程带上三个新的干活线程（客户付款线程）
*在这个例子中，三个驱动线程是new Thread,
*干活线程是buyer1，buyer2，buyer3，锁住的对象是Account（共享资源）
*/ 
Thread threads[] = new Thread[3];
Thread threads[] = new Thread[3];
threads[0] = new Thread(buyer1, "第一个顾客" );
threads[1] = new Thread(buyer2, "第二个顾客" );
threads[2] = new Thread(buyer3, "第三个顾客" );
/**
/**
* 付钱，客户任务已经完成，就是等银行返回消息了。
*/
threads[0].start();
threads[1].start();
threads[2].start();
  }
  
}
只是为了理解monitor，所以选择
其中的一个运行结果：
第一个顾客 取得钥匙
第一个顾客:100.0
第二个顾客 取得钥匙
第二个顾客:225
第三个顾客 取得钥匙
第三个顾客:535.0

    $j.ajax({
        url:"/outbound/index.php/Tasklist/insert",
   	    type:"post",
   	    data:{task_name:task_name,task_templates:task_templates,remark:remark},
   	    success:function(data){
   	        str = eval("("+data+")");
            if(str.status=="1"){
                alert(str[0].result);
                frameclose();
            }else{
                alert(str[0].result);
            }
   	    }  
    })  
 

 
 

 
 
json  格式 
 
{['result':'成功']}

Java中如何获得一个对象所对应的类及Class类的简单理解
 
前言
 
在之前的学习中，所用的编程语言主要是Python，最近开始学习Java，熟悉Python的同学应该会知道在Python中有一个函数type()，通过这个函数可以非常方便地获得一个变量的类型。那么在Java中可不可以实现类似的功能呢？答案当然是可以的，一个比较简单的方法就是利用Java中Class类来实现。
 
利用Class类的方法获得一个对象所属于的类
 
在这里先给出一个例子：
 
List<Integer> listTest = new ArrayList<>();
System.out.println(listTest.getClass().getName());
 
运行这段代码会输出：
 
java.util.ArrayList
 
在这一段代码中，新建了一个ArrayList类型的实例listTest，在其后的一行代码中，用.getclass()方法获得了listTest变量所属于的类，并再用.getName()将这个类的名称输出出来。
 同时，也可以用.toString()将完整的信息打印出来：
 
System.out.println(listTest.getClass().toString());
 
结果为
 
class java.util.ArrayList
 
可以看到，用.getClass()方法可以很方便地获得我们想要知道的对象变量所对应的类的名称。
 而以上是用于实例的获取其类的类型的方法，与之类似的还有.class()方法，这个方法是针对类的，如：
 
System.out.println(ArrayList.class.getName());
 
输出为：
 
java.util.ArrayList
 
关于Class类的一些理解
 
在上面的例子中，我们看到Class类有一些非常方便的应用，所以可以来简单地了解以下Class类的内容。
 
java是一门比较纯粹的面向对象的语言，在这样一门语言里，一切皆为对象。当然还是有着一些例外，比如从开发者的角度看静态成员和普通数据类型就不属于对象，静态成员只属于某个类，而不属于对象，而普通数据类型是因为处于对性能的考虑，因为处理对象需要额外的系统开销，所以颗将基本数据类型当作对象，就会给语言性能带来负面影响，因此，在Java中基本数据类型是不作为对象来使用的，不过，在需要的时候可以通过方便的装箱（boxing）与开箱（unboxing）来实现基本数据类型与对象之间的转换。
 
当然，既然上面说了是从开发者的角度看，肯定对应着其它的角度，比如若在JVM的视角，会将所有的原始类型都当作对象处理，但是会为原始类型创建非常轻量级的对象，相比于其装箱的包装类的功能要少得多，但是会有很多优化。而对于静态成员，就可以通过Class类来进行理解。
 
那么，既然Java中，一切皆为对象，那么在程序里的类本身是不是对象呢？答案为是的，在Java中有这样专门的一个类java.lang.Class，在程序中所写的每一个类都既有着自己的对象，同时它自己本身也是Class类的对象。
 在Java中，程序运行的期间，Java的运行时系统会始终为所有的对象维护一个被称为运行时的类型标识，这个信息跟踪着每个对象所属的类，虚拟机则利用女性是类型信息来选择相应的方法执行，而保存这些信息的类就是Class类。而在之前我们的例子中的的.getClass()方法返回的就是这样一个Class类型的实例，获得Class类的方法主要有以下三种：
 
 
Object类中的getClass()方法
 
 
Class类中的forName()方法，例：Class cl = Class.forName(className); 输入参数为雷鸣，获得类名对应的Class对象。
 
 
如果T是任意的Java类型，则T.class返回匹配的类对象。
 
 
其中的1、3条即为本文开始时的两个例子。
 
在这里，需要注意的一点时，一个Class对象实际上上表示的是一个类型，而这个类型未必一定是一种类，如int不是类，但int.class是一个Class类型的对象。
 
Class类还有其它一些比较有用的地方，比如，虚拟机为每个类型管理一个Class对象，因此，可以利用==运算符实现两个类对象比较的操作，如：
 
if (e.getClass() == Employee.class)...
 
还有一个很有用的方法newInstance()，可以用来动态地创建一个类的实例。例如：
 
e.getClass().newInstance();
 
这个语句创建了一个与e具有相同类的类型的实例。newInstance方法调用默认的构造器（没有参数的构造器）初始化新创建的对象。如果这个类没有默认的构造器，就会抛出一个异常。
 
将forName与newInstance配合使用，可以根据存储在字符串中的类名创建一个对象。
 
String s = "java.util.Random";
Object m = Class.forName(s).newInstance;
 
同时，还需要知道，Class类的构造函数为私有函数，即我们无法像定义普通类的实例那样，用new的方法来构造Class的实例，若要获得Class的实例可以通过上面介绍的三种方法。