依次點(diǎn)擊設(shè)置--高級(jí)選項(xiàng)--內(nèi)容設(shè)置--cookies--選擇“顯示cookies和其他網(wǎng)站數(shù)據(jù)按鈕就可以看到了

firefox:
      依次點(diǎn)開FF瀏覽器工具選項(xiàng)： 工具》選項(xiàng)》隱私》在歷史選項(xiàng)框中選擇“使用自定義歷史記錄設(shè)置” 進(jìn)入后，再選擇“顯示Cookies”.出來一個(gè)對(duì)話框，里面就是FF記錄的所有Cookie。其值你也可以很方便查看到。

      死鎖是一個(gè)經(jīng)典的多線程問題，因?yàn)椴煌木€程都在等待那些根本不可能被釋放的鎖，

從而導(dǎo)致所有的工作都無法完成。假設(shè)有兩個(gè)線程，分別代表兩個(gè)饑餓的人，他們必須共享刀叉并輪流吃飯。

他們都需要獲得兩個(gè)鎖：共享刀和共享叉的鎖。假如線程 "A" 獲得了刀，而線程 "B" 獲得了叉。

線程 A 就會(huì)進(jìn)入阻塞狀態(tài)來等待獲得叉，而線程 B 則阻塞來等待 A 所擁有的刀。
      

<!-- Spring security Filter -->
<filter>
    <filter-name>springSecurityFilterChain</filter-name>
    <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
</filter>
<filter-mapping>
    <filter-name>springSecurityFilterChain</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

public interface UserDetails extends Serializable {
    
    GrantedAuthority[] getAuthorities();

    String getPassword();

    String getUsername();

    boolean isAccountNonExpired();

    boolean isAccountNonLocked();

    boolean isCredentialsNonExpired();

    boolean isEnabled();
}

public interface UserDetailsService {
    UserDetails loadUserByUsername(String username)
        throws UsernameNotFoundException, DataAccessException;
}

public class AuthorityInterceptor extends AbstractInterceptor {
    private static final long serialVersionUID = 1L; 
    private Logger LOG = Logger.getLogger(AuthorityInterceptor.class.getName()); 
    
    private AuthorityUtil authorityUtil;
    
    public String intercept(ActionInvocation invocation) throws Exception {
        if (authorityUtil == null) {
            authorityUtil = new AuthorityUtil();
        }
        
        //獲取當(dāng)前用戶所有的權(quán)限
        List<OperatorPurviewDO> operatorPurviews = getCurrentOperatorPurviews();
        
        //獲取當(dāng)前操作的url
        String currentUrl = getCurrentUrl(); 
        
         //如果是超級(jí)管理員或有當(dāng)前url的權(quán)限，那么直接返回。
        if (OperatorUtil.getIsSuperAdmin() ||(OperatorUtil.getLoginName()!=null&&authorityUtil.checkUrl(operatorPurviews, currentUrl))){
             return invocation.invoke();
        }
         
        if (!OperatorUtil.getIsSuperAdmin()&&operatorPurviews.size()==0) {
            LOG.info("此用戶:" + OperatorUtil.getLoginName() + " 沒有任何角色，沒有權(quán)限執(zhí)行任何功能"); 
            return "loginErr"; 
        }   
            return "authorityErr";
    }

<interceptor name="authorityInterceptor" class="com.wasu.eis.authority.AuthorityInterceptor" /> 

            <interceptor-stack name="eisManagerBasicStack">
                <interceptor-ref name="exception"/>
                <interceptor-ref name="alias"/>
                <interceptor-ref name="servletConfig"/>
                <interceptor-ref name="prepare"/>
                <interceptor-ref name="i18n"/>
                <interceptor-ref name="chain"/>
                <interceptor-ref name="debugging"/>
                <interceptor-ref name="profiling"/>
                <interceptor-ref name="scopedModelDriven"/>
                <interceptor-ref name="modelDriven"/>
                <interceptor-ref name="checkbox"/>
                <interceptor-ref name="staticParams"/>
                <interceptor-ref name ="fileUploadStack" /> 
                <interceptor-ref name="params">
                  <param name="excludeParams">dojo\..*</param>
                </interceptor-ref>
                <interceptor-ref name="conversionError"/>
                <interceptor-ref name="validation">
                    <param name="excludeMethods">input,back,cancel,browse</param>
                </interceptor-ref>
                <interceptor-ref name="workflow">
                    <param name="excludeMethods">input,back,cancel,browse</param>
                </interceptor-ref>
            </interceptor-stack>
            
            <interceptor-stack name="authorityInterceptorStack">
                <interceptor-ref name="authorityInterceptor" />
                <interceptor-ref name="eisManagerBasicStack" />
            </interceptor-stack>

<default-interceptor-ref name="authorityInterceptorStack"/>

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 
/**
    本例介紹一個(gè)特殊的隊(duì)列:BlockingQueue,如果BlockQueue是空的,從BlockingQueue取東西的操作將會(huì)被阻斷進(jìn)入等待狀態(tài),直到BlockingQueue進(jìn)了東西才會(huì)被喚醒.同樣,如果BlockingQueue是滿的,任何試圖往里存東西的操作也會(huì)被阻斷進(jìn)入等待狀態(tài),直到BlockingQueue里有空間才會(huì)被喚醒繼續(xù)操作.
    本例再次實(shí)現(xiàn)11.4線程----條件Condition中介紹的籃子程序,不過這個(gè)籃子中最多能放的蘋果數(shù)不是1,可以隨意指定.當(dāng)籃子滿時(shí),生產(chǎn)者進(jìn)入等待狀態(tài),當(dāng)籃子空時(shí),消費(fèi)者等待.
 */
/**
    使用BlockingQueue的關(guān)鍵技術(shù)點(diǎn)如下:
    1.BlockingQueue定義的常用方法如下:
        1)add(anObject):把a(bǔ)nObject加到BlockingQueue里,即如果BlockingQueue可以容納,則返回true,否則招聘異常
        2)offer(anObject):表示如果可能的話,將anObject加到BlockingQueue里,即如果BlockingQueue可以容納,則返回true,否則返回false.
        3)put(anObject):把a(bǔ)nObject加到BlockingQueue里,如果BlockQueue沒有空間,則調(diào)用此方法的線程被阻斷直到BlockingQueue里面有空間再繼續(xù).
        4)poll(time):取走BlockingQueue里排在首位的對(duì)象,若不能立即取出,則可以等time參數(shù)規(guī)定的時(shí)間,取不到時(shí)返回null
        5)take():取走BlockingQueue里排在首位的對(duì)象,若BlockingQueue為空,阻斷進(jìn)入等待狀態(tài)直到Blocking有新的對(duì)象被加入為止
    2.BlockingQueue有四個(gè)具體的實(shí)現(xiàn)類,根據(jù)不同需求,選擇不同的實(shí)現(xiàn)類
        1)ArrayBlockingQueue:規(guī)定大小的BlockingQueue,其構(gòu)造函數(shù)必須帶一個(gè)int參數(shù)來指明其大小.其所含的對(duì)象是以FIFO(先入先出)順序排序的.
        2)LinkedBlockingQueue:大小不定的BlockingQueue,若其構(gòu)造函數(shù)帶一個(gè)規(guī)定大小的參數(shù),生成的BlockingQueue有大小限制,若不帶大小參數(shù),所生成的BlockingQueue的大小由Integer.MAX_VALUE來決定.其所含的對(duì)象是以FIFO(先入先出)順序排序的
        3)PriorityBlockingQueue:類似于LinkedBlockQueue,但其所含對(duì)象的排序不是FIFO,而是依據(jù)對(duì)象的自然排序順序或者是構(gòu)造函數(shù)的Comparator決定的順序.
        4)SynchronousQueue:特殊的BlockingQueue,對(duì)其的操作必須是放和取交替完成的.
    3.LinkedBlockingQueue和ArrayBlockingQueue比較起來,它們背后所用的數(shù)據(jù)結(jié)構(gòu)不一樣,導(dǎo)致LinkedBlockingQueue的數(shù)據(jù)吞吐量要大于ArrayBlockingQueue,但在線程數(shù)量很大時(shí)其性能的可預(yù)見性低于ArrayBlockingQueue.         
 */
public class BlockingQueueTest {
       /**定義裝蘋果的籃子*/
       public static class Basket{
              //籃子,能夠容納3個(gè)蘋果
              BlockingQueue<String> basket = new ArrayBlockingQueue<String>(3);
              //生產(chǎn)蘋果,放入籃子
              public void produce() throws InterruptedException{
                     //put方法放入一個(gè)蘋果,若basket滿了,等到basket有位置
                     basket.put("An apple");
              }
              //消費(fèi)蘋果,從籃子中取走
              public String consume() throws InterruptedException{
                     //take方法取出一個(gè)蘋果,若basket為空,等到basket有蘋果為止
                     return basket.take();
              }
       }
       //測(cè)試方法
       public static void testBasket(){
              final Basket basket = new Basket();//建立一個(gè)裝蘋果的籃子
              //定義蘋果生產(chǎn)者
              class Producer implements Runnable{
                     public void run(){
                            try{
                                   while(true){
                                          //生產(chǎn)蘋果
                                          System.out.println("生產(chǎn)者準(zhǔn)備生產(chǎn)蘋果: " + System.currentTimeMillis());
                                          basket.produce();
                                          System.out.println("生產(chǎn)者生產(chǎn)蘋果完畢: " + System.currentTimeMillis());
                                          //休眠300ms
                                          Thread.sleep(300);
                                   }
                            }catch(InterruptedException ex){
                            }
                     }
              }
              //定義蘋果消費(fèi)者
              class Consumer implements Runnable{
                     public void run(){
                            try{
                                   while(true){
                                          //消費(fèi)蘋果
                                          System.out.println("消費(fèi)者準(zhǔn)備消費(fèi)蘋果: " + System.currentTimeMillis());
                                          basket.consume();
                                          System.out.println("消費(fèi)者消費(fèi)蘋果完畢: " + System.currentTimeMillis());
                                          //休眠1000ms
                                          Thread.sleep(1000);
                                   }
                            }catch(InterruptedException ex){
                            }
                     }
              }
              ExecutorService service = Executors.newCachedThreadPool();
              Producer producer = new Producer();
              Consumer consumer = new Consumer();
              service.submit(producer);
              service.submit(consumer);
              //程序運(yùn)行5s后,所有任務(wù)停止
              try{
                     Thread.sleep(5000);
              }catch(InterruptedException ex){
              }
              service.shutdownNow();
       }
       public static void main(String[] args){
              BlockingQueueTest.testBasket();
       }
}

兩者的區(qū)別有：
 1、最主要是sleep方法沒有釋放鎖，而wait方法釋放了鎖，使得其他線程可以使用同步控制塊或者方法。 2、這兩個(gè)方法來自不同的類分別是Thread和Object

 3、wait，notify和notifyAll只能在同步控制方法或者同步控制塊里面使用，而sleep可以在
    任何地方使用
   synchronized(x){
      x.notify()
     //或者wait()
   }
  4、sleep必須捕獲異常，而wait，notify和notifyAll不需要捕獲異常

public class CeilAndFloor {
    public static void main(String[] args) {
    /*
        這兩個(gè)寶貝函數(shù)的主要任務(wù)是截掉小數(shù)以后的位數(shù).
        區(qū)別是: floor總是把數(shù)字變得越來越小，而ceil總是把數(shù)字變大。
                其實(shí)名字可以理解floor是地板，ceil是天花板。
    */

        System.out.println("==============Math.floor()==============");
        System.out.println("Math.floor(99.1) = " + Math.floor(99.1));
        System.out.println("Math.floor(-99.1) = " + Math.floor(-99.1));
        System.out.println("Math.floor(99.9) = " + Math.floor(99.9));
        System.out.println("Math.floor(99.9) = " + Math.floor(-99.9));
        
        System.out.println("\n\n==============Math.ceil()==============");
        System.out.println("Math.ceil(99.1) = " + Math.ceil(99.1));
        System.out.println("Math.ceil(-99.1) = " + Math.ceil(-99.1));
        System.out.println("Math.ceil(99.9) = " + Math.ceil(99.9));
        System.out.println("Math.ceil(99.9) = " + Math.ceil(-99.9));
        
    }
}
結(jié)果
==============Math.floor()==============
Math.floor(99.1) = 99.0
Math.floor(-99.1) = -100.0
Math.floor(99.9) = 99.0
Math.floor(99.9) = -100.0

==============Math.ceil()==============
Math.ceil(99.1) = 100.0
Math.ceil(-99.1) = -99.0
Math.ceil(99.9) = 100.0
Math.ceil(99.9) = -99.0