如果你想從頭學習Jmeter，可以看看這個系列的文章哦

https://www.cnblogs.com/poloyy/category/1746599.html

 

了解一哈什麼是 CSV 文件

• 為了實現簡單的數據存儲，是一個純文本的文件
• 最通用的一種文件格式，它可以非常容易地被導入各種PC表格及數據庫中
• CSV 文件可以用記事本、excel打開；用記事本打開的話，每一列數據都用逗號隔開

 

為什麼要用 CSV 數據文件？

• 從外部導入測試數據，相當於數據參數化
• 通過從文件中導入大量的測試數據，來模擬大量真實用戶發送併發請求

 

CSV 數據文件設置

 

CSV 數據文件設置界面介紹

 

字段含義

字段	含義
Filename	文件名
File encoding	文件編碼
Variable Names	變量名稱 多個變量用 , 分隔
Ignore first line	忽略首行 只在設置了變量名稱后才生效
Delimiter	分隔符 默認 ,
Allow quoted data?	是否允許帶引號
Recycle on EOF?	遇到文件結束符EOF 后再次循環
Stop thread on EOF?	遇到文件結束符EOF 后停止運行線程？
Sharing mode	線程共享模式

後續通過各種栗子來深入理解常用字段的含義

 

單個字段的栗子

csv 測試數據

這裏用記事本方式當 CSV 數據文件，共有 10 條記錄

 

線程組結構樹

${num} 是計數器裏面聲明的變量，從 1 開始遞增到 15

 

線程組屬性

線程數和數據量一致，都是 15

 

csv 數據文件設置

 

運行結果

 

知識點

• 忽略首行 True：一般首行都是字段名字，比如栗子的 mobile，一般都需要忽略除非沒有字段名
• 是否允許帶引號 False：可以看到有引號的三條記錄 8、9、10，都還是保留了引號
• 再次循環 True：csv 文件共有 10 條記錄，但線程數有 15 個，循環 10 次后，重頭開始循環；可以看到 11-15的手機號和1-5的手機號
• 停止線程 False：取了 10 次值之後就到了文件尾部，但並不會停止運行線程，後面會舉個反例

 

多個字段的綜合栗子

csv 測試數據

兩個字段，共有 10 條記錄，最後三條記錄有分別有三種引號

 

csv 數據文件設置

線程組結構樹和上面栗子差不多一樣，線程數仍然 = 15

和第一個例子的配置項相反：不忽略首行，允許帶引號，遇到文件結束符不再循環

 

運行結果

• 不忽略首行就會把首行的字段名都返回回來，如：1-mobile-age
• 數據有雙引號 “” 時，會把雙引號忽略掉， ” 單引號不算
• EOF 是文件結束符，沒有開啟再次循環時，會直接返回 EOF

 

開啟遇到文件結束符停止線程

還是上個栗子的線程組，只是改了下配置項

 

運行結果

可以看到，線程數 = 15，但只有 10 條數據，當跑了 10 個線程后，沒有數據了，所以停止運行

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理
【其他文章推薦】

※USB CONNECTOR掌控什麼技術要點? 帶您認識其相關發展及效能

※台北網頁設計公司這麼多該如何選擇?

※智慧手機時代的來臨，RWD網頁設計為架站首選

※評比南投搬家公司費用收費行情懶人包大公開

※幫你省時又省力,新北清潔一流服務好口碑

※回頭車貨運收費標準

Python的functools模塊中有一種函數叫“偏函數”，自從接觸它以來，發現確實是一個很有用且簡單的函數，相信你看完這篇文章，你也有相見恨晚的感覺。

我們都知道，函數入參可以設置默認值來簡化函數調用，而偏函數的作用就是將入參進行默認填充，降低函數使用的難度。

如int()函數，可以將字符型轉換為整型，且默認的都是以十進制形式來轉換，那為什麼一定是十進制呢？如果想用以二進制的形式轉換呢？其實我們可以看一下int函數它本身的定義

可以看到int有兩種用法，可以傳一個位置參數，還可以多傳一個關鍵字參數base，也就是基於什麼格式轉換，默認不傳base參數是以十進制轉換。所以，用二進制形式轉換的話只要base=2即可（見下方代碼）

1 value = int('10000') 2 print(value)    # 10000
3 
4 value = int('10000', base=2) 5 print(value)    # 16

如果每次轉換的字符串的時候都要輸入base參數，顯得很麻煩，因此偏函數的作用就體現出來了，可以使用functools.partial()函數來重新定義

1 from functools import partial 2 
3 int2 = partial(int, base=2) 4 res = int2('10000') 5 print(res)     # 16

到這裏，你應該已經感覺到了偏函數的一點點魅力吧，那我們再從多個角度進一步看透它。

• 自定義函數的使用

1 def add(a, b, c): 2     print('a=',a,'b=',b,'c=',c) 3     return a + b + c 4 
5 add10 = partial(add, 10) 6 res = add10(1, 2)     # a= 10 b= 1 c= 2

如上代碼中，partial(add, 10)入參並沒有指定哪個關鍵字參數，函數卻默認的將這個值傳給了第一個參數a，那就說明，當沒有指定默認參數時，默認賦值給第一個參數，餘下參數按位置參數賦值。

• 當入參為可變參數時

1 def sum(*args): 2     s = 0 3     for n in args: 4         s += n 5     return s 6 
7 sum10 = partial(sum, 10) 8 print(sum10(1))    # 11
9 print(sum10())     # 10

按上述理解，沒有指定默認參數時，默認賦給第一個參數，那麼第一個參數永遠是10，後面再傳入參的話就從第二個參數開始計算，因此會實現10 + 1 = 11 的結果。同樣，如果不繼續傳參的話，只有默認的10，所以結果就是10

• 當入參為可變關鍵字參數時

 1 D = {'value1':10, 'value2':20}
 2 V = {'Default':100}
 3 def show(**kw):
 4     for k in kw:
 5         print(k, kw.get(k))
 6 
 7 showDef = partial(show, **V)    
 8 showDef(**D)   
 9 # Default 100
10 # value1 10
11 # value2 20

同理，此時入參由於是可變參數，因此默認是第一個傳入，先打印Default關鍵字，這裏關注一下函數的寫法，可變關鍵字參數要寫成（**V）

• 當入參為限制的關鍵字參數時

1 def student(name, * , age, city): 2     print('name:',name, 'age:',age, 'city:',city) 3 
4 studentAge = partial(student, age=20) 5 studentAge('Tom','Beijing') 6 # TypeError: student() takes 1 positional argument but 2 positional arguments (and 1 keyword-only argument) were given

我們知道，當用*號分隔開，表示後面的關鍵字參數是必傳的，因此對於默認參數也是同樣適用，即當參數為必傳時，偏函數也需要對每個關鍵字參數設置默認值。因此修改後為

1 studentAge = partial(student, age=20, city='Beijing') 2 studentAge('Tom')  # name: Tom age: 20 city: Beijing

 

綜上，偏函數可以將目標函數的部分參數固化后，重新定義為新的函數，降低了編碼的複雜度，尤其是當參數很多的時候，或者只用到其中某些參數的場景下時，效果更為顯著。

到這裏，你是否有了相見恨晚的感覺呢？簡單函數小技巧，非常實用的偏函數用法就介紹完了，如果覺得有用，請關注我，後續會繼續分享更多好用好知識。

 

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※帶您來了解什麼是 USB CONNECTOR  ?

※自行創業缺乏曝光? 網頁設計幫您第一時間規劃公司的形象門面

※如何讓商品強力曝光呢? 網頁設計公司幫您建置最吸引人的網站，提高曝光率!

※綠能、環保無空污,成為電動車最新代名詞，目前市場使用率逐漸普及化

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

※教你寫出一流的銷售文案?

Java8之前的日期和時間API，存在一些問題，最重要的就是線程安全的問題。這些問題都在Java8中的日期和時間API中得到了解決，而且Java8中的日期和時間API更加強大。

傳統時間格式化的線程安全問題

示例：

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.*;

public class TestOldSimpleDateFormat {
    public static void main(String[] args) throws Exception {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Callable<Date> task = new Callable<Date>() {
            @Override
            public Date call() throws Exception {
                return sdf.parse("2020-01-01");
            }
        };
        ExecutorService pool = Executors.newFixedThreadPool(10);
        List<Future<Date>> list = new ArrayList<>();
        for (int i=0;i<10;i++){
            Future<Date> future = pool.submit(task);
            list.add(future);
        }
        for (Future<Date> future : list){
            System.out.println(future.get());
        }

　　　　　pool.shutdown();
    }
}

以上代碼運行會報錯：

 

 

報錯緣由：取部分源碼解釋

    /**
     * SimpleDateFormat 類的 parse 方法 部分源碼
     */
    public Date parse(String source) throws ParseException
    {
        ParsePosition pos = new ParsePosition(0);
        Date result = parse(source, pos); 
        if (pos.index == 0)
            throw new ParseException("Unparseable date: \"" + source + "\"" ,
                pos.errorIndex);
        return result;
    }

public Date parse(String text, ParsePosition pos)
    {
        // 省略上面諸多代碼
        Date parsedDate;

        CalendarBuilder calb = new CalendarBuilder();
        try {
            //這裏這個 calendar 對象是 SimpleDateFormat 類的父類 DateFormat 中的屬性  ： protected Calendar calendar;
            parsedDate = calb.establish(calendar).getTime();//這個 calb.establish(calendar) 方法中，這個方法中的主要步驟不是原子操作，並且會對 calendar 對象進行修改，所以在多線程環境下就會出現線程安全問題。
            // 省略下面面諸多代碼
        }
        catch (IllegalArgumentException e) {
            //省略.........................
            return null;
        }
        return parsedDate;
    }

 Calendar establish(Calendar cal) {
        boolean weekDate = isSet(WEEK_YEAR)
                            && field[WEEK_YEAR] > field[YEAR];
        if (weekDate && !cal.isWeekDateSupported()) {
            // Use YEAR instead
            if (!isSet(YEAR)) {
                set(YEAR, field[MAX_FIELD + WEEK_YEAR]);
            }
            weekDate = false;
        }

        cal.clear();
        // Set the fields from the min stamp to the max stamp so that
        // the field resolution works in the Calendar.
        for (int stamp = MINIMUM_USER_STAMP; stamp < nextStamp; stamp++) {
            for (int index = 0; index <= maxFieldIndex; index++) {
                if (field[index] == stamp) {
                    cal.set(index, field[MAX_FIELD + index]);
                    break;
                }
            }
        }

        if (weekDate) {
            int weekOfYear = isSet(WEEK_OF_YEAR) ? field[MAX_FIELD + WEEK_OF_YEAR] : 1;
            int dayOfWeek = isSet(DAY_OF_WEEK) ?
                                field[MAX_FIELD + DAY_OF_WEEK] : cal.getFirstDayOfWeek();
            if (!isValidDayOfWeek(dayOfWeek) && cal.isLenient()) {
                if (dayOfWeek >= 8) {
                    dayOfWeek--;
                    weekOfYear += dayOfWeek / 7;
                    dayOfWeek = (dayOfWeek % 7) + 1;
                } else {
                    while (dayOfWeek <= 0) {
                        dayOfWeek += 7;
                        weekOfYear--;
                    }
                }
                dayOfWeek = toCalendarDayOfWeek(dayOfWeek);
            }
            cal.setWeekDate(field[MAX_FIELD + WEEK_YEAR], weekOfYear, dayOfWeek);
        }
        return cal;
    }

綜上，我們可以看到 SimpleDateFormat 類中的parse 方法，調用了 CalendarBuilder 的 establish(calendar) 方法，並在方法中，對 calendar 對象進行了各種判斷及修改，並且這些操作都不是原子操作或同步操作，而這個calendar 對象又是 SimpleDateFormat 的父類 DateFormat 的一個實例變量，所以，在多線程同時調用SimpleDateFormat 的 parse 方法的時候，就會出現線程安全問題。

針對以上異常，JAVA8之前的解決辦法：

1. 將 SimpleDateFormat 對象定義成局部變量。

2. 加鎖。

3. 使用ThreadLocal，每個線程都擁有自己的SimpleDateFormat對象副本。

示例（加鎖）：

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Callable<Date> task = new Callable<Date>() {
            @Override
            public synchronized Date call() throws Exception {//加個同步，解決問題
                return sdf.parse("2020-01-01");
//                return DateFormatThreadLocal.convert("2020-01-01");
            }
        };
        ExecutorService pool = Executors.newFixedThreadPool(10);
        List<Future<Date>> list = new ArrayList<>();
        for (int i=0;i<10;i++){
            Future<Date> future = pool.submit(task);
            list.add(future);
        }
        for (Future<Date> future : list){
            System.out.println(future.get());
        }
        pool.shutdown();

 

示例（ThreadLocal）：

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;

public class DateFormatThreadLocal {
    private static final ThreadLocal<DateFormat> df = new ThreadLocal<DateFormat>() {
        protected DateFormat initialValue() {
            return new SimpleDateFormat("yyyy-MM-dd");
        }
    };
    public static Date convert(String source) throws Exception {
        return df.get().parse(source);
    }
}


////////////////////////////////////////////////////////////////

public class TestOldSimpleDateFormat {
    public static void main(String[] args) throws Exception {
//        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Callable<Date> task = new Callable<Date>() {
            @Override
            public Date call() throws Exception {
//                return sdf.parse("2020-01-01");
                return DateFormatThreadLocal.convert("2020-01-01");
            }
        };
        ExecutorService pool = Executors.newFixedThreadPool(10);
        List<Future<Date>> list = new ArrayList<>();
        for (int i=0;i<10;i++){
            Future<Date> future = pool.submit(task);
            list.add(future);
        }
        for (Future<Date> future : list){
            System.out.println(future.get());
        }

　　　　　pool.shutdown();

} }

 

JAVA8的解決辦法：使用新的API（DateTimeFormatter  和 LocalDate ）

示例：

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

public class TestOldSimpleDateFormat {
    public static void main(String[] args) throws Exception {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

        Callable<LocalDate> task = new Callable<LocalDate>() {
            @Override
            public LocalDate call() throws Exception {
//                return sdf.parse("2020-01-01");
                return LocalDate.parse("2020-01-01",formatter);
            }
        };
        ExecutorService pool = Executors.newFixedThreadPool(10);
        List<Future<LocalDate>> list = new ArrayList<>();
        for (int i=0;i<10;i++){
            Future<LocalDate> future = pool.submit(task);
            list.add(future);
        }
        for (Future<LocalDate> future : list){
            System.out.println(future.get());
        }
        pool.shutdown();
    }
}

 

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理
【其他文章推薦】

※USB CONNECTOR掌控什麼技術要點? 帶您認識其相關發展及效能

※台北網頁設計公司這麼多該如何選擇?

※智慧手機時代的來臨，RWD網頁設計為架站首選

※評比南投搬家公司費用收費行情懶人包大公開

※幫你省時又省力,新北清潔一流服務好口碑

※回頭車貨運收費標準