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

最近我我开发的一个系统里边有老的代码， 这些老代码没有使用Spring， 我们准备用Spring改写老代码， 但是写到一半， 发现问题很多，然后我们又不想丢掉我们写好的新代码， 所以我们就需要找到一个方法，使我们能够在老的代码里访问Spring的bean. 我们都知道要访问Spring bean 我们就必须得到一个ApplicationContext 或者 BeanFactory 对象， 而ApplicationContext的BeanFactory 的子类， 拥有更强大的功能，ApplicationContext可以在服务器启动的时候自动实例化所有的bean,而 BeanFactory只有在调用getBean()的时候才去实例化那个bean, 这也是我们为什么要得到一个ApplicationContext对象， 事实上Spring2相关的web应用默认使用的是ApplicationContext对象去实例化bean， 换一句话说， 在服务器启动的时候，Spring容器就已经实例化好了一个ApplicationContext对象，所以我们要在老的代码里尝试去获取这个对象。 但是如何才能得到一个ApplicationContext对象呢？方法很多，最常用的办法就是用ClassPathXmlApplicationContext， FileSystemClassPathXmlApplicationContext， FileSystemXmlApplicationContext 等对象去加载Spring配置文件，这样做也是可以， 但是在加载Spring配置文件的时候，就会生成一个新的ApplicaitonContext对象而不是Spring容器帮我们生成的哪一个， 这样就产生了冗余， 所以我们在这里不采用这种加载文件的方式，我们使用ApplicationContextAware让Spring容器传递自己生成的ApplicationContext给我们， 然后我们把这个ApplicationContext设置成一个类的静态变量， 这样我们就随时都可以在老的代码里得到Application的对象了。
 
ApplicationContextHelper
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
/**
 *
 * @author MinFei
 */
public class ApplicationContextHelper implements ApplicationContextAware {
    private static ApplicationContext appCtx;
    /**
     * 此方法可以把ApplicationContext对象inject到当前类中作为一个静态成员变量。
     * @param applicationContext ApplicationContext 对象.
     * @throws BeansException
     */
    @Override
    public void setApplicationContext( ApplicationContext applicationContext ) throws BeansException {
        appCtx = applicationContext;
    }
    /**
     * 这是一个便利的方法，帮助我们快速得到一个BEAN
     * @param beanName bean的名字
     * @return 返回一个bean对象
     */
    public static Object getBean( String beanName ) {
        return appCtx.getBean( beanName );
    }
}
 
 
配置 ApplicationContextHelper
<bean id="SpringApplicationContext" class="com.company.helper.ApplicationContextHelper"></bean>
 
使用些列方法去得到一个bean
 BeanExample beanExample= (BeanExample )ApplicationContextHelper.getBean( "beanExample" );


这样我们在老代码里取得了一个Spring配置的对象， 然后我们就可以自由自在的在老代码里边享受Spring提供的功能。
 
 
 
希望本博文对你有帮助。
 

 

JAVA复制对象给另一个对象 


标签： javahibernateobject
2012-03-23 16:46 14881人阅读 评论(0) 收藏 举报



 分类：
 

J2SE（113） 



版权声明：本文为博主原创文章，未经博主允许不得转载。



今天算是遇到一个问题了。相当苦恼。

需求如下：有2个相同id的对象，但它们的值不同。其中一个对象要用到另一个对象的属性值。

由于在hibernate的sessionFactory().getSession中不能存在2个相同id的对象。故此，想出复制对象。

找了很多地方，发现有2种方法可以达到复制对象的目的，只是最后这种方法还是没有解决我的问题。仅此记下来吧。

1，克隆clone

Java支持克隆一个对象的值到另一个对象，简单的克隆和深度克隆，深度克隆可能包括继承，嵌套，没有用到，所以也就没怎么去研究它。

首先，克隆的对象需要实现 Cloneable接口，重写其中的clone()方法，为了使clone()方法在外部可用，需要将重写的方法访问修饰符改成public级别。





[java] view
 plain copy


 print?


@Override  

    public Object clone() throws CloneNotSupportedException {  

        return super.clone();  

    }  




[java] view
 plain copy


 print?


dv=(Deliverymanreport)deliverymanreport.clone();//克隆对象  


dv是deliverymanreport克隆的一个对象。它拥用克隆后的属性和方法。






2，序列化和反序列化Serializable

序列化的对象要实现Serializable接口才能实现序列化。

序列化后，通过反序列化可以得到和当前对象一样的对象。它比克隆来得更准备。但也就不一定最好，如果这个对象在之前被修改，序列化后可能就会出问题了。





[java] view
 plain copy


 print?


ByteArrayOutputStream byteOut = new ByteArrayOutputStream();  

ObjectOutputStream out= new ObjectOutputStream(byteOut);  

out.writeObject(deliverymanreport);//写对象，序列化  

ByteArrayInputStream byteIn = new ByteArrayInputStream(byteOut.toByteArray());   

 dv=(Deliverymanreport)in.readObject(); //读对象，反序列化  


序列化经常用于文件传递的读取。尤其是在缓存中用得比较多，通过序列化可以将对象缓存在硬盘中。这在登录系统缓存用户权限和角色等信息最常见。而用对克隆对象，也不失为一种很好的方法。

来源：http://www.cnblogs.com/seesea125/archive/2012/04/03/2431176.html




一、 面向对象，这个对象到底是什么？

 

    这个对象不是C#中的实例，C#中我们把一个类的实例也叫做对象，这种对象严格的说应该是面向对象的编程实现(OOP)中的对象，面向对象编程，也不是面向类的实例编程。对象的定义是人们要进行研究的任何事物，从最简单的整数到复杂的飞机等均可看作对象，它不仅能表示具体的事物，还能表示抽象的规则、计划或事件。也有的定义为“一切都是对象”然而面向对象也不能简单的等价理解成面向任何事物编程，面对一切编程？开玩笑，呵呵。

因此面向对象这个对象，指的是客体。所谓客体是指客观存在的对象实体和主观抽象的概念。 

 

二、 为什么要面向对象？

 

面向对象是为了解决系统的可维护性，可扩展性，可重用性，我们再进一步思考，面向对象为什么能解决系统的可维护性，可扩展性，可重用性？ 

面向对象产生的历史原因有下面两点： 

1、 计算机是帮助人们解决问题的，然而计算机终究是个机器，他只会按照人所写的代码，一步一步的执行下去，最终得到了结果，因此无论程序多么的复杂，计算机总是能轻松应付，结构化编程，就是按照计算机的思维写出的代码，但是人看到这么复杂的逻辑，就无法维护和扩展了。

2、 结构化设计是以功能为目标来设计构造应用系统，这种做法导致我们设计程序时，不得不将客体所构成的现实世界映射到由功能模块组成的解空间中，这种转换过程，背离了人们观察和解决问题的基本思路。 

    可见结构化设计在设计系统的时候，无法解决重用、维护、扩展的问题，而且会导致逻辑过于复杂，代码晦涩难懂。于是人们就想，能不能让计算机直接模拟现实的环境，用人类解决问题的思路，习惯，步骤来设计相应的应用程序？这样的程序，人们在读它的时候，会更容易理解，也不需要再把现实世界和程序世界之间来回做转换。 

    与此同时，人们发现，在现实世界中存在的客体是问题域中的主角，所谓客体是指客观存在的对象实体和主观抽象的概念，这种客体具有属性和行为，而客体是稳定的，行为不稳定的，同时客体之间具有各种联系，因此面向客体编程，比面向行为编程，系统会更稳定，在面对频繁的需求更改时，改变的往往是行为，而客体一般不需要改变，所以我们就把行为封装起来，这样改变时候只需要改变行为即可，主架构则保持了稳定。 

于是面向对象就产生了。 

然而人们追求的系统可维护性，可扩展性，可重用性又是怎么在面向对象中体现出来的呢？ 

首先看看面向对象的三大特征： 

封装：找到变化并且把它封装起来，你就可以在不影响其它部分的情况下修改或扩展被封装的变化部分，这是所有设计模式的基础，就是封装变化，因此封装的作用，就解决了程序的可扩展性。 

继承：子类继承父类，可以继承父类的方法及属性，实现了多态以及代码的重用，因此也解决了系统的重用性和扩展性，但是继承破坏了封装，因为他是对子类开放的，修改父类会导致所有子类的改变，因此继承一定程度上又破坏了系统的可扩展性，所以继承需要慎用，只有明确的IS-A关系才能使用，同时继承在在程序开发过程中重构得到的，而不是程序设计之初就使用继承，很多面向对象开发者滥用继承，结果造成后期的代码解决不了需求的变化了。因此优先使用组合，而不是继承，是面向对象开发中一个重要的经验。 

多态：接口的多种不同的实现方式即为多态。接口是对行为的抽象，刚才在封装提到，找到变化部分并封装起来，但是封装起来后，怎么适应接下来的变化？这正是接口的作用，接口的主要目的是为不相关的类提供通用的处理服务,我们可以想象一下。比如鸟会飞，但是超人也会飞，通过飞这个接口，我们可以让鸟和超人，都实现这个接口，这就实现了系统的可维护性，可扩展性。 

    因此面向对象能实现人们追求的系统可维护性，可扩展性，可重用性。面向对象是一种编程思想，起初，“面向对象”是专指在程序设计中采用封装、继承、多态等设计方法，但面向对象的思想已经涉及到软件开发的各个方面，比如现在细分为了面向对象的分析(OOA)，面向对象的设计(OOD)，面向对象的编程实现(OOP) 

 

三 面对对象编程，分为几个步骤？ 

 

面向对象是一种思想，他让我们在分析和解决问题时，把思维和重点转向现实中的客体中来，然后通过UML工具理清这些客体之间的联系，最后用面向对象的语言实现这种客体以及客体之间的联系。它分为面向对象的分析(OOA)，面向对象的设计(OOD)，面向对象的编程实现(OOP)三个大的步骤。

1、首先是分析需求，先不要思考怎么用程序实现它，先分析需求中稳定不变的客体都是些什么，这些客体之间的关系是什么。

2、把第一步分析出来的需求，通过进一步扩充模型，变成可实现的、符合成本的、模块化的、低耦合高内聚的模型。

3、使用面向对象的实现模型 

 

四 面向过程到面向对象思维如何转变？ 

 

    当我们习惯了面向过程编程时，发现在程序过程中到处找不到需要面向对象的地方，最主要的原因，是思维没有转变。程序员通常在拿到一个需求的时候，第一个反应就是如何实现这个需求，这是典型的面向过程的思维过程，而且很快可能就实现了它。而面向对象，面对的却是客体，第一步不是考虑如何实现需求，而是进行需求分析，就是根据需求找到其中的客体，再找到这些客体之间的联系。因此面向过程和面向对象的思维转变的关键点，就是在第一步设计，拿到需求后，一定先不要考虑如何实现它，而是通过UML建模，然后按照UML模型去实现它。这种思路的转变，可能需要个过程。 

 

五 面向对象和基于对象的区别 

 

    “面向对象”和“基于对象”都实现了“封装”的概念，但是面向对象实现了“继承和多态”，而“基于对象”没有实现这些。因此在我们进行WEB开发，普通三层开发中，基本上是基于对象的实现，因为只是实现了封装，但是没有使用继承和多态，不过这也正常，WEB开发，大部分功能就是简单的增删改查，中间的BLL层基本就是直接New一个DAL的实例就return了，关系数据库已经为我们做了很多工作，所以大部分的工作，就是简单读取然后显示了，因此没有复杂的需求的时候，基于过程也没什么不对，面向过程也没什么不对，实用是压倒一切的因素。