短暂transient和加锁synchronized 使用

Java的serialization提供了一种持久化对象实例的机制。当持久化对象时，可能有一个特殊的对象数据成员，我们不想    用serialization机制来保存它。为了在一个特定对象的一个域上关闭serialization，可以在这个域前加上关键字transient。    transient是Java语言的关键字，用来表示一个域不是该对象串行化的一部分。当一个对象被串行化的时候，transient型变量的值不包括在串行化的表示中，然而非transient型的变量是被包括进去的。  短暂transient     例子     将例子运行的时候，你们就会发现 private transient String name;  这个字段的输出情况是什么，从而更好的理解 transient   的具体意思 package com.geong.test.entity; import java.io.Serializable; public class UserBean implements Serializable{ private String id ; private transient String name; private String password; public UserBean() { super(); // TODO Auto-generated constructor stub } public UserBean(String id,String name,String password) { this.id=id; this.name=name; this.password=password; } public String getId() { return id; } public void setId(String id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getPassword() { return password; } public void setPassword(String password) { this.password = password; } }  package com.geong.test.serializable; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.util.ArrayList; import java.util.List; import com.geong.test.entity.UserBean; public class SerializableTestUtl {   /**      * 序列化写入文件      * @param u List：用户集合      */     public static void SaveUserData(List<UserBean> date)     {         try {             File f=new File("user.dat");//打开文件             if (!f.exists()) {                 f.createNewFile();             }             //字节写入流             FileOutputStream fos = new FileOutputStream(f);             //对象字节流对象             ObjectOutputStream oos=new ObjectOutputStream(fos);             //写入一个用户集合对象             oos.writeObject(date);             oos.close();             fos.close();         } catch (Exception ex) {             ex.printStackTrace();         }     }     /**      * 反序列化读取文件中的数据      * @return List:用户集合      */     public static List<UserBean> getUserData()     {         List<UserBean> date=new ArrayList<UserBean>();         try {            File f=new File("user.dat");            if (f.exists()) {            FileInputStream fis = new FileInputStream(f);            //对象字节流对象            ObjectInputStream  ois=new ObjectInputStream (fis);            date= (List<UserBean>)ois.readObject();            ois.close();            fis.close();            }         }         catch(ClassNotFoundException fex)         {             fex.printStackTrace();         }catch (Exception iex) {            iex.printStackTrace();         }         return date;     }                    public static void main(String[] args) { UserBean ub=null; List<UserBean> date=new ArrayList<UserBean>(); for (int i = 0; i <4; i++) { date.add(new UserBean("111"+i,"2222"+i,"33333"+i)); } SerializableTestUtl.SaveUserData(date); System.out.println("--------"); List<UserBean> lstBean=SerializableTestUtl.getUserData(); for (UserBean userBean : lstBean) { System.out.println(userBean.getId()); System.out.println(userBean.getName()); System.out.println(userBean.getPassword()); } } } synchronized 方法 声明是为了定义变量的作用范围和作用域 通过在方法声明中加入 synchronized关键字来声明 synchronized 方法。 synchronized 方法控制对类成员变量的访问：每个类实例对应一把锁，每个 synchronized 方法都必须获得调用该方法的类实例的锁方能执行，否则所属线程阻塞，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。这种机制确保了同一时刻对于每一个类实例，其所有声明为 synchronized 的成员函数中至多只有一个处于可执行状态（因为至多只有一个能够获得该类实例对应的锁），从而有效避免了类成员变量的访问冲突（只要所有可能访问类成员变量的方法均被声明为synchronized）。 synchronized 块 通过 synchronized关键字来声明synchronized 块。语法如下： synchronized(syncObject) { //允许访问控制的代码 } synchronized 块是这样一个代码块，其中的代码必须获得对象 syncObject （如前所述，可以是类实例或类）的锁方能执行，具体机制同前所述。由于可以针对任意代码块，且可任意指定上锁的对象，故灵活性较高。