tensorflow中的學習率調整策略

通常為了模型能更好的收斂,隨着訓練的進行,希望能夠減小學習率,以使得模型能夠更好地收斂,找到loss最低的那個點.

tensorflow中提供了多種學習率的調整方式.在搜索decay.可以看到有多種學習率的衰減策略.

  • cosine_decay
  • exponential_decay
  • inverse_time_decay
  • linear_cosine_decay
  • natural_exp_decay
  • noisy_linear_cosine_decay
  • polynomial_decay

本文介紹兩種學習率衰減策略,指數衰減和多項式衰減.

  • 指數衰減
tf.compat.v1.train.exponential_decay(
    learning_rate,
    global_step,
    decay_steps,
    decay_rate,
    staircase=False,
    name=None
)

learning_rate 初始學習率
global_step 當前總共訓練多少個迭代
decay_steps 每xxx steps后變更一次學習率
decay_rate 用以計算變更后的學習率
staircase: global_step/decay_steps的結果是float型還是向下取整

學習率的計算公式為:decayed_learning_rate = learning_rate * decay_rate ^ (global_step / decay_steps)

我們用一段測試代碼來繪製一下學習率的變化情況.

#coding=utf-8
import matplotlib.pyplot as plt
import tensorflow as tf

x=[]
y=[]
N = 200 #總共訓練200個迭代

num_epoch = tf.Variable(0, name='global_step', trainable=False)
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    for num_epoch in range(N):
        ##初始學習率0.5,每10個迭代更新一次學習率.
        learing_rate_decay = tf.train.exponential_decay(learning_rate=0.5, global_step=num_epoch, decay_steps=10, decay_rate=0.9, staircase=False)
        learning_rate = sess.run([learing_rate_decay])
        y.append(learning_rate)

#print(y)

x = range(N)
fig = plt.figure()
ax.set_xlabel('step')
ax.set_ylabel('learing rate')
plt.plot(x, y, 'r', linewidth=2)
plt.show()

結果如圖:

  • 多項式衰減
tf.compat.v1.train.polynomial_decay(
    learning_rate,
    global_step,
    decay_steps,
    end_learning_rate=0.0001,
    power=1.0,
    cycle=False,
    name=None
)

設定一個初始學習率,一個終止學習率,然後線性衰減.cycle控制衰減到end_learning_rate后是否保持這個最小學習率不變,還是循環往複. 過小的學習率會導致收斂到局部最優解,循環往複可以一定程度上避免這個問題.
根據cycle是否為true,其計算方式不同,如下:

#coding=utf-8
import matplotlib.pyplot as plt
import tensorflow as tf

x=[]
y=[]
z=[]
N = 200 #總共訓練200個迭代

num_epoch = tf.Variable(0, name='global_step', trainable=False)
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    for num_epoch in range(N):
        ##初始學習率0.5,每10個迭代更新一次學習率.
        learing_rate_decay = tf.train.polynomial_decay(learning_rate=0.5, global_step=num_epoch, decay_steps=10, end_learning_rate=0.0001, cycle=False)
        learning_rate = sess.run([learing_rate_decay])
        y.append(learning_rate)
        
        learing_rate_decay2 = tf.train.polynomial_decay(learning_rate=0.5, global_step=num_epoch, decay_steps=10, end_learning_rate=0.0001, cycle=True)
        learning_rate2 = sess.run([learing_rate_decay2])
        z.append(learning_rate2)
#print(y)

x = range(N)
fig = plt.figure()
ax.set_xlabel('step')
ax.set_ylabel('learing rate')
plt.plot(x, y, 'r', linewidth=2)
plt.plot(x, z, 'g', linewidth=2)
plt.show()

繪圖結果如下:

cycle為false時對應紅線,學習率下降到0.0001后不再下降. cycle=true時,下降到0.0001后再突變到一個更大的值,在繼續衰減,循環往複.

在代碼里,通常通過參數去控制不同的學習率策略,例如

def _configure_learning_rate(num_samples_per_epoch, global_step):
  """Configures the learning rate.

  Args:
    num_samples_per_epoch: The number of samples in each epoch of training.
    global_step: The global_step tensor.

  Returns:
    A `Tensor` representing the learning rate.

  Raises:
    ValueError: if
  """
  # Note: when num_clones is > 1, this will actually have each clone to go
  # over each epoch FLAGS.num_epochs_per_decay times. This is different
  # behavior from sync replicas and is expected to produce different results.
  decay_steps = int(num_samples_per_epoch * FLAGS.num_epochs_per_decay /
                    FLAGS.batch_size)

  if FLAGS.sync_replicas:
    decay_steps /= FLAGS.replicas_to_aggregate

  if FLAGS.learning_rate_decay_type == 'exponential':
    return tf.train.exponential_decay(FLAGS.learning_rate,
                                      global_step,
                                      decay_steps,
                                      FLAGS.learning_rate_decay_factor,
                                      staircase=True,
                                      name='exponential_decay_learning_rate')
  elif FLAGS.learning_rate_decay_type == 'fixed':
    return tf.constant(FLAGS.learning_rate, name='fixed_learning_rate')
  elif FLAGS.learning_rate_decay_type == 'polynomial':
    return tf.train.polynomial_decay(FLAGS.learning_rate,
                                     global_step,
                                     decay_steps,
                                     FLAGS.end_learning_rate,
                                     power=1.0,
                                     cycle=False,
                                     name='polynomial_decay_learning_rate')
  else:
    raise ValueError('learning_rate_decay_type [%s] was not recognized' %
                     FLAGS.learning_rate_decay_type)

推薦一篇: 對各種學習率衰減策略描述的很詳細.並且都有配圖,可以很直觀地看到各種衰減策略下學習率變換情況.

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

【其他文章推薦】

※專營大陸空運台灣貨物推薦

台灣空運大陸一條龍服務

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

彰化搬家費用,南投搬家費用,距離,噸數怎麼算?達人教你簡易估價知識!

雪佛蘭Bolt電動車進入試生產階段

據報導,雪佛蘭Bolt電動車已經進入到試生產階段,在這通過道橫在經銷商的大門之前,要測試產品和生產設備的穩定性,確保所有下線的汽車都能達標。目前,已經有車輛從美國密歇根州Orion Township的生產車間下線。

在很多方面,Bolt都被認為是Model 3的強有力競爭對手,性能相當定價也在3萬美元左右的水準。兩家公司都致力於將電動汽車的成本降低到普通消費者可以接受的範圍內,並承諾充滿電之後續航里程能達到320公里。

本站聲明:網站內容來源於EnergyTrend https://www.energytrend.com.tw/ev/,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※專營大陸空運台灣貨物推薦

台灣空運大陸一條龍服務

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

彰化搬家費用,南投搬家費用,距離,噸數怎麼算?達人教你簡易估價知識!

SpringBoot 整合NoSql

通用配置

maven依賴

添加Spring-Web和Spring-Security依賴,使用Spring-Security是因為使用SpringBoot的Redis依賴時,必須添加Spring-Security。在新版本SpringBoot才會這樣。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

properties配置

8080端口指定一下,因為下面雙開服務器這個配置必須在這裏显示加上。

server.port=8080

測試類

@RestController
public class HelloController {

    @Value("${server.port}")
    Integer port;

    @GetMapping("/set")
    public String set(HttpSession session) {
        session.setAttribute("name", "johnson");
        return String.valueOf(port);
    }

    @GetMapping("/get")
    public String get(HttpSession session) {
        return (String)session.getAttribute("name") + port;
    }
}

整合Redis

maven依賴

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

連接redis必須要密碼,否則連接不上,所以你的redis服務器必須設置密碼

spring.redis.host=127.0.0.1
spring.redis.database=0
spring.redis.port=6379
spring.redis.password=123456

啟動后,瀏覽器打開localhost:8080,賬號默認為user,密碼在控制台打印出來了,可以去看看。頁面如下:

Redis下的Session共享

當我們開啟兩個或多個Tomcat時,如何在這兩個Tomcat服務中共享Session呢,而Spring直接扔個依賴給你,安裝這個依賴就好了。
???????????? execute me!?
就是這麼簡單,添加spring-session-data-redis依賴就好了,如下:

<dependency>
    <groupId>org.springframework.session</groupId>
    <artifactId>spring-session-data-redis</artifactId>
</dependency>

測試Session共享

使用maven使用package指令打包出來出來后(IDEA的Maven工具有package按鈕,點一下就好),在target目錄下可以看到你打包好的jar包,就像這樣:

進入到tartget目錄后,打開兩個命令窗口, 分別輸入以下命令:

java -jar sessionhare-0.0.1-SNAPSHOT.jar  --server.port=8080 //窗口1命令
java -jar sessionhare-0.0.1-SNAPSHOT.jar  --server.port=8081 //窗口2命令

然後打開頁面localhost:8080,賬號默認為user,密碼可以在8080的控制台看到,登錄成功后,
再打開頁面localhost:8081,你會發現不需要再次登錄啦,Session共享成功!

Nginx的負載均衡

安裝Nginx可以參考我之前的文章
如果是Ubuntu或者其他類型的系統,就依賴項不同,安裝方式還是一樣的。

nginx配置

nginx配置在路徑在/usr/local/nginx/conf/nginx.conf, 修改配置如下:
http模塊下修改。

    upstream colablog.cn {
        server 127.0.0.1:8080 weight=1;
        server 127.0.0.1:8081 weight=1;
    }
    server {
        listen      80;
        server_name localhost;
        
        location / {
           proxy_pass http://colablog.cn;
           proxy_redirect default;
        }
    }

修改完nginx配置後記得要重新加載一下配置文件,修改配置文件后必須重新指定配置文件,否則啟動會報錯。

sudo /usr/local/nginx/sbin/nginx -c /usr/local/nginx/conf/nginx.conf //重新指定配置文件
sudo /usr/local/nginx/sbin/nginx -s reload //重新啟動nginx

把剛才項目打包出來的jar包扔到Linux服務器上,讓程序在服務器後台運行,使用如下命令:

$ nohup java -jar sessionhare-0.0.1-SNAPSHOT.jar --server.port=8080 > 8080.log &
$ nohup java -jar sessionhare-0.0.1-SNAPSHOT.jar --server.port=8081 > 8081.log &

打開你Linux服務器的ip地址就可以看到了。在瀏覽器打開你的虛擬機ip/set你的虛擬機ip/get,重複打開幾次就會發現訪問不同的端口。

MongoDb

整合MongoDb就像整合Redis那麼簡單,依賴和配置文件搞一下就行了

maven依賴

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>

properties配置

spring.data.mongodb.host=127.0.0.1
spring.data.mongodb.authentication-database=admin
spring.data.mongodb.username=johnson
spring.data.mongodb.password=123456
spring.data.mongodb.port=27017
spring.data.mongodb.database=johnson

這樣就已經配置好了,不過我們還是測試一下吧。

測試

Book實體類

public class Book {

    private Integer id;

    private String name;

    private String author;

    @Override
    public String toString() {
        return "Book{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", author='" + author + '\'' +
                '}';
    }

    public Integer getId() { return id; }

    public void setId(Integer id) { this.id = id; }

    public String getName() { return name; }

    public void setName(String name) { this.name = name; }

    public String getAuthor() { return author; }

    public void setAuthor(String author) { this.author = author; }
}

dao接口

public interface BookDao extends MongoRepository<Book, Integer> {
    List<Book> findBookByNameContaining(String name);
}

測試類

@SpringBootTest
class MongoApplicationTests {
    @Autowired
    BookDao dao;

    @Test
    void contextLoads() {
        Book book = new Book();
        book.setName("colablog");
        book.setId(1);
        book.setAuthor("johnson");
        dao.insert(book);
    }

    @Test
    public void getList() {
        List<Book> all = dao.findAll();
        System.out.println(all);
        List<Book> cola = dao.findBookByNameContaining("cola");
        System.out.println(cola);
    }

    @Autowired
    MongoTemplate template;

    @Test
    public void test1() {
        Book book = new Book();
        book.setName("colablog2");
        book.setId(2);
        book.setAuthor("johnson2");
        template.insert(book);

        List<Book> all = template.findAll(Book.class);
        System.out.println(all);
    }
}

總結

文章主要是根據總結了視頻第六章內容,
代碼貼的有點多,因為測試用例的關係,真是抱歉,因為有測試用例才能證明程序能走通。
好了,感謝各位的閱讀,文章若有不足之處或更好的建議,請在下方留言,Thanks(・ω・)ノ。

個人博客網址: https://colablog.cn/

如果我的文章幫助到您,可以關注我的微信公眾號,第一時間分享文章給您

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

【其他文章推薦】

※專營大陸空運台灣貨物推薦

台灣空運大陸一條龍服務

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

彰化搬家費用,南投搬家費用,距離,噸數怎麼算?達人教你簡易估價知識!

年幼江豚大嶼山擱淺 本年第14宗

摘錄自2020年03月15日星島日報報導

香港海洋公園保育基金昨(14日)接報通知跟進在大嶼山水口一宗鯨豚擱淺個案,為本年度的第14宗。

該擱淺的年幼江豚,性別有待確定,身長133厘米。其屍身已嚴重腐爛。個案並沒有表面傷痕,保育基金已把江豚帶回海洋公園化驗。

香港海洋公園保育基金呼籲公眾,若發現懷疑鯨豚擱淺個案,可致電 1823 熱線,並提供發現擱淺的時間、地點、相片(如有),讓行動組能盡快到場跟進。

海洋
生態保育
國際新聞
香港
江豚
擱淺死亡

本站聲明:網站內容來源環境資訊中心https://e-info.org.tw/,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

台北網頁設計公司這麼多,該如何挑選?? 網頁設計報價省錢懶人包”嚨底家”

網頁設計公司推薦更多不同的設計風格,搶佔消費者視覺第一線

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

小三通海運與一般國際貿易有何不同?

小三通快遞通關作業有哪些?

一、netcore跨平台之 Linux上部署netcore和webapi

這幾天閑着的時候在linux上部署了一下netcore webapi,下面就紀要一下這個過程。

中間遇到不少的坑,心裏都是淚啊。

 話不多說,開始幹活。

————————————————————————

第一步,你得先創建一個netcore的接口,這個我就簡單創建一個接口。

關於開發工具,我用的是vs2017,當然最新的vs2019也出來了,你可以用新的,都沒關係。

開始選擇創建項目,如圖所示,這個入門的程序員都應該懂

 

 

 選擇API

 

 

 點擊確定按鈕就創建成功。

如圖打開 Program.cs 

 

 

 在這裏添加一段代碼

 

代碼添加后

 

 

 這樣代碼就寫好了。

接下來就是發布。

 

選擇文件夾,選擇你要發布的項目的位置。

 

 

 點擊高級配置如下,注意下,這裏的目標框架是2.2版本,所以我們在linux上安裝的也是2.2。

 這裏我就遇到過坑,我vs發布的是2.0的版本,結果我linux是2.2,就各種運行報錯,後來改成2.2就好了。

 

 最後保存併發布就好了。

netcore項目的創建和發布就這樣結束了。

第二步,你得準備一個linux服務器,然後安裝環境

如果你條件允許,可以直接在阿里雲或者騰訊雲、華為雲、百度雲上買一個服務器。

新用戶是白菜價哦,(這裏真不是打廣告)當然你可以在你電腦上安裝一個VMware虛擬機。

具體安裝步驟百度一下一大把,這裏就不演示了。

我就在在百度雲買了一個linux服務器,嗯,價格還算便宜,畢竟新用戶,為什麼用百度雲??

當然不是因為他好,而是我阿里雲已經不是新用戶了

好了,我們繼續。

用xshell登錄到你的linux服務器上。(如果不懂linux,沒關係,你總會百度吧)

登錄成功后,你可以在直接輸入如下命令

sudo yum install dotnet-sdk-2.2

 

 點擊確認,你需要等一段時間,如果你服務器網速很差,那麼你可以會等很久。

 如下圖示,遇到這裏你需要點擊敲一下你的鍵盤上的 y 回車即可

 這個時候系統開始慢慢的下載了,請耐心等待即可。

 

 

 終於下載完成了

 

你可以輸入下面的命令看看是否成功

dotnet --version

显示如下,表示按照成功

 

 

 

然後我們把發布包上傳到服務器上來

我這裏用的是xftp工具,當然也有其他工具可,下圖所示是我安裝的兩個工具,大家可以去下載安裝。

 

 

這裏給大家提供一些我在網盤保存的一些工具

Xshell+Xftp真正破解版    https://pan.baidu.com/s/1Ew1XPg11sakpc8mvK6QsHg 

 打開xftp並連接到服務器,如下所示

 

 

 

我這裏用的root權限,這裏進來就直接就是root根目錄了

然後右鍵點擊創建一個目錄用來保存你上傳的netcore文件,嗯,就取名netcore吧

 

 

 

 

 

 

 然後在左邊找到你剛剛發布的那個包的位置,並且點擊右邊的netcore進入到對應的目錄中

 

 

 

然後全選左邊的所有文件,並右鍵然後點擊傳輸,如圖所示

 

 

然後文件就開始傳輸了

 

 

 

 

 等下面的傳輸沒有記錄了,那麼恭喜你,你傳遞完成了。

 

 有人可能會問為啥這麼多文件,我vs2017本來沒有2.2版本,後來我在本機安裝了2.2,結果發布后就這麼多……

然後我們再次回到xshell看看

輸入命令 ll 可以看到我們新加了一個文件 netcore

 

 然後輸入命令cd  進入到我們上傳的這個發布包中。

然後在輸入命令 ll

cd netcore
ll

我們可以找到WebApiTest.dll文件

 

 然後輸入命令

dotnet WebApiTest.dll

如圖所示,就恭喜你你的項目運行正常。

 

 然後你Ctrl+C結束掉這個程序,這裏只能在服務器內部訪問,外面是不能訪問的。

 然後輸入如下命令

dotnet WebApiTest.dll   --server.urls "http://*:6666"

如圖所示

 

 然後用postman或者一些在線工具訪問這個接口,如圖所示,那麼恭喜你成功了

這個測試工具的網站:https://www.sojson.com/httpRequest/

 

 

 好了,到這裏netcore在linux上配置就基本完成了,接下來下一篇我們開始講nginx的配置,以及讓netcore運行在nginx下。

 

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

【其他文章推薦】

※專營大陸空運台灣貨物推薦

台灣空運大陸一條龍服務

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

彰化搬家費用,南投搬家費用,距離,噸數怎麼算?達人教你簡易估價知識!

go中的數據結構-通道channel

1. channel的使用

  很多文章介紹channel的時候都和併發揉在一起,這裏我想把它當做一種數據結構來單獨介紹它的實現原理。

  channel,通道。golang中用於數據傳遞的一種數據結構。是golang中一種傳遞數據的方式,也可用作事件通知。

1.1 聲明、傳值、關閉

  使用chan關鍵字聲明一個通道,在使用前必須先創建,操作符 <- 用於指定通道的方向,發送或接收。如果未指定方向,則為雙向通道。

 1 //聲明和創建
 2 var ch chan int      // 聲明一個傳遞int類型的channel
 3 ch := make(chan int) // 使用內置函數make()定義一個channel
 4 ch2 := make(chan interface{})         // 創建一個空接口類型的通道, 可以存放任意格式
 5 
 6 type Equip struct{ /* 一些字段 */ }
 7 ch2 := make(chan *Equip)             // 創建Equip指針類型的通道, 可以存放*Equip
 8 
 9 //傳值
10 ch <- value          // 將一個數據value寫入至channel,這會導致阻塞,直到有其他goroutine從這個channel中讀取數據
11 value := <-ch        // 從channel中讀取數據,如果channel之前沒有寫入數據,也會導致阻塞,直到channel中被寫入數據為止
12 
13 ch := make(chan interface{})  // 創建一個空接口通道
14 ch <- 0 // 將0放入通道中
15 ch <- "hello"  // 將hello字符串放入通道中
16 
17 //關閉
18 close(ch)            // 關閉channel

  把數據往通道中發送時,如果接收方一直都沒有接收,那麼發送操作將持續阻塞。Go 程序運行時能智能地發現一些永遠無法發送成功的語句並報錯:

fatal error: all goroutines are asleep - deadlock! 
//運行時發現所有的 goroutine(包括main)都處於等待 goroutine。

1.2 四種重要的通道使用方式

無緩衝通道

  通道默認是無緩衝的,無緩衝通道上的發送操作將會被阻塞,直到有其他goroutine從對應的通道上執行接收操作,數據傳送完成,通道繼續工作。

package main

import (
    "fmt"
    "time"
)
var done chan bool
func HelloWorld() {
    fmt.Println("Hello world goroutine")
    time.Sleep(1*time.Second)
    done <- true
}
func main() {
    done = make(chan bool)  // 創建一個channel
    go HelloWorld()
    <-done
}
1 //輸出
2 //Hello world goroutine

  由於main不會等goroutine執行結束才返回,前文專門加了sleep輸出為了可以看到goroutine的輸出內容,那麼在這裏由於是阻塞的,所以無需sleep。

  將代碼中”done <- true”和”<-done”,去掉再執行,沒有上面的輸出內容。

管道

  通道可以用來連接goroutine,這樣一個的輸出是另一個輸入。這就叫做管道:

 

 1 package main
 2 
 3 import (
 4     "fmt"
 5     "time"
 6 )
 7 var echo chan string
 8 var receive chan string
 9 
10 // 定義goroutine 1 
11 func Echo() {
12     time.Sleep(1*time.Second)
13     echo <- "這是一次測試"
14 }
15 
16 // 定義goroutine 2
17 func Receive() {
18     temp := <- echo // 阻塞等待echo的通道的返回
19     receive <- temp
20 }
21 
22 
23 func main() {
24     echo = make(chan string)
25     receive = make(chan string)
26 
27     go Echo()
28     go Receive()
29 
30     getStr := <-receive   // 接收goroutine 2的返回
31 
32     fmt.Println(getStr)
33 }

  輸出字符串:”這是一次測試”。

  在這裏不一定要去關閉channel,因為底層的垃圾回收機制會根據它是否可以訪問來決定是否自動回收它。(這裏不是根據channel是否關閉來決定的)

單向通道類型
 1 package main
 2 
 3 import (
 4     "fmt"
 5     "time"
 6 )
 7 
 8 // 定義goroutine 1
 9 func Echo(out chan<- string) {   // 定義輸出通道類型
10     time.Sleep(1*time.Second)
11     out <- "這又是一次測試"
12     close(out)
13 }
14 
15 // 定義goroutine 2
16 func Receive(out chan<- string, in <-chan string) { // 定義輸出通道類型和輸入類型
17     temp := <-in // 阻塞等待echo的通道的返回
18     out <- temp
19     close(out)
20 }
21 
22 
23 func main() {
24     echo := make(chan string)
25     receive := make(chan string)
26 
27     go Echo(echo)
28     go Receive(receive, echo)
29 
30     getStr := <-receive   // 接收goroutine 2的返回
31 
32     fmt.Println(getStr)
33 }

  輸出:這又是一次測試。

緩衝管道

  goroutine的通道默認是是阻塞的,那麼有什麼辦法可以緩解阻塞? 答案是:加一個緩衝區。

  創建一個緩衝通道:

1 ch := make(chan string, 3) // 創建了緩衝區為3的通道
2 
3 //==
4 len(ch)   // 長度計算
5 cap(ch)   // 容量計算

  緩衝通道傳遞數據示意圖:

 

2. 內部結構 

  Go語言channel是first-class的,意味着它可以被存儲到變量中,可以作為參數傳遞給函數,也可以作為函數的返回值返回。作為Go語言的核心特徵之一,雖然channel看上去很高端,但是其實channel僅僅就是一個數據結構而已,具體定義在 $GOROOT/src/runtime/chan.go里。如下:

 1 type hchan struct {
 2   qcount uint   // 隊列中的總數據
 3   dataqsiz uint   // 循環隊列的大小
 4   buf unsafe.Pointer // 指向dataqsiz元素數組
 5   elemsize uint16  // 
 6   closed uint32 
 7   elemtype *_type // 元素類型
 8   sendx uint // 發送索引
 9   recvx uint // 接收索引
10   recvq waitq // 接待員名單, 因recv而阻塞的等待隊列。
11   sendq waitq // 發送服務員列表, 因send而阻塞的等待隊列。
12   //鎖定保護hchan中的所有字段,以及幾個在此通道上阻止的sudogs中的字段。
13   //按住此鎖定時不要更改另一個G的狀態(尤其是不要準備G),因為這可能會導致死鎖堆棧縮小。
14   lock mutex 
15 }

   其中一個核心的部分是存放channel數據的環形隊列,由qcount和elemsize分別指定了隊列的容量和當前使用量。dataqsize是隊列的大小。elemalg是元素操作的一個Alg結構體,記錄下元素的操作,如copy函數,equal函數,hash函數等。

  如果是帶緩衝區的chan,則緩衝區數據實際上是緊接着Hchan結構體中分配的。不帶緩衝的 channel ,環形隊列 size 則為 0。

1 c = (Hchan*)runtime.mal(n + hint*elem->size);

  另一重要部分就是recvq和sendq兩個鏈表,一個是因讀這個通道而導致阻塞的goroutine,另一個是因為寫這個通道而阻塞的goroutine。如果一個goroutine阻塞於channel了,那麼它就被掛在recvq或sendq中。WaitQ是鏈表的定義,包含一個頭結點和一個尾結點:

1 struct    WaitQ
2 {
3     SudoG*    first;
4     SudoG*    last;
5 };

  隊列中的每個成員是一個SudoG結構體變量:

1 struct    SudoG
2 {
3     G*    g;        // g和selgen構成
4     uint32    selgen;        // 指向g的弱指針
5     SudoG*    link;
6     int64    releasetime;
7     byte*    elem;        // 數據元素
8 };

  該結構中主要的就是一個g和一個elem。elem用於存儲goroutine的數據。讀通道時,數據會從Hchan的隊列中拷貝到SudoG的elem域。寫通道時,數據則是由SudoG的elem域拷貝到Hchan的隊列中。

 

  基本的寫channel操作,在底層運行時庫中對應的是一個runtime.chansend函數。

1 c <- v
  在運行時庫中會執行:
1 void runtime·chansend(ChanType *t, Hchan *c, byte *ep, bool *pres, void *pc)

  其中c就是channel,ep是取變量v的地址。這裏的傳值約定是調用者負責分配好ep的空間,僅需要簡單的取變量地址就夠了。pres參數是在select中的通道操作使用的。

  這個函數首先會區分是同步還是異步。同步是指chan是不帶緩衝區的,因此可能寫阻塞,而異步是指chan帶緩衝區,只有緩衝區滿才阻塞。在同步的情況下,由於channel本身是不帶數據緩存的,這時首先會查看Hchan結構體中的recvq鏈表時否為空,即是否有因為讀該管道而阻塞的goroutine。如果有則可以正常寫channel,否則操作會阻塞。

  recvq不為空的情況下,將一個SudoG結構體出隊列,將傳給通道的數據(函數參數ep)拷貝到SudoG結構體中的elem域,並將SudoG中的g放到就緒隊列中,狀態置為ready,然後函數返回。如果recvq為空,否則要將當前goroutine阻塞。此時將一個SudoG結構體,掛到通道的sendq鏈表中,這個SudoG中的elem域是參數eq,SudoG中的g是當前的goroutine。當前goroutine會被設置為waiting狀態並掛到等待隊列中。

  在異步的情況,如果緩衝區滿了,也是要將當前goroutine和數據一起作為SudoG結構體掛在sendq隊列中,表示因寫channel而阻塞。否則也是先看有沒有recvq鏈表是否為空,有就喚醒。跟同步不同的是在channel緩衝區不滿的情況,這裏不會阻塞寫者,而是將數據放到channel的緩衝區中,調用者返回。

  讀channel的操作也是類似的,對應的函數是runtime.chansend。一個是收一個是發,基本的過程都是差不多的。

  當協程嘗試從未關閉的 channel 中讀取數據時,內部的操作如下:

  • 當 buf 非空時,此時 recvq 必為空,buf 彈出一個元素給讀協程,讀協程獲得數據後繼續執行,此時若 sendq 非空,則從 sendq 中彈出一個寫協程轉入 running 狀態,待寫數據入隊列 buf ,此時讀取操作 <- ch 未阻塞;
  • 當 buf 為空但 sendq 非空時(不帶緩衝的 channel),則從 sendq 中彈出一個寫協程轉入 running 狀態,待寫數據直接傳遞給讀協程,讀協程繼續執行,此時讀取操作 <- ch 未阻塞;
  • 當 buf 為空並且 sendq 也為空時,讀協程入隊列 recvq 並轉入 blocking 狀態,當後續有其他協程往 channel 寫數據時,讀協程才會重新轉入 running 狀態,此時讀取操作 <- ch 阻塞。

  類似的,當協程嘗試往未關閉的 channel 中寫入數據時,內部的操作如下:

  • 當隊列 recvq 非空時,此時隊列 buf 必為空,從 recvq 彈出一個讀協程接收待寫數據,此讀協程此時結束阻塞並轉入 running 狀態,寫協程繼續執行,此時寫入操作 ch <- 未阻塞;
  • 當隊列 recvq 為空但 buf 未滿時,此時 sendq 必為空,寫協程的待寫數據入 buf 然後繼續執行,此時寫入操作 ch <- 未阻塞;
  • 當隊列 recvq 為空並且 buf 為滿時,此時寫協程入隊列 sendq 並轉入 blokcing 狀態,當後續有其他協程從 channel 中讀數據時,寫協程才會重新轉入 running 狀態,此時寫入操作 ch <- 阻塞。

  當關閉 non-nil channel 時,內部的操作如下:

  • 當隊列 recvq 非空時,此時 buf 必為空,recvq 中的所有協程都將收到對應類型的零值然後結束阻塞狀態;
  • 當隊列 sendq 非空時,此時 buf 必為滿,sendq 中的所有協程都會產生 panic ,在 buf 中數據仍然會保留直到被其他協程讀取。

  空通道是指將一個channel賦值為nil,或者定義后不調用make進行初始化。按照Go語言的語言規範,讀寫空通道是永遠阻塞的。其實在函數runtime.chansend和runtime.chanrecv開頭就有判斷這類情況,如果發現參數c是空的,則直接將當前的goroutine放到等待隊列,狀態設置為waiting。

  讀一個關閉的通道,永遠不會阻塞,會返回一個通道數據類型的零值。這個實現也很簡單,將零值複製到調用函數的參數ep中。寫一個關閉的通道,則會panic。關閉一個空通道,也會導致panic。

3. channel的高級用法

3.1 條件變量(condition variable)

  類型於 POSIX 接口中線程通知其他線程某個事件發生的條件變量,channel 的特性也可以用來當成協程之間同步的條件變量。因為 channel 只是用來通知,所以 channel 中具體的數據類型和值並不重要,這種場景一般用 strct {} 作為 channel 的類型。

一對一通知

  類似 pthread_cond_signal() 的功能,用來在一個協程中通知另個某一個協程事件發生:

 1 package main
 2 
 3 import (
 4     "fmt"
 5     "time"
 6 )
 7 
 8 func main() {
 9     ch := make(chan struct{})
10     nums := make([]int, 100)
11 
12     go func() {
13         time.Sleep(time.Second)
14         for i := 0; i < len(nums); i++ {
15             nums[i] = i
16         }
17         // send a finish signal
18         ch <- struct{}{}
19     }()
20 
21     // wait for finish signal
22     <-ch
23     fmt.Println(nums)
24 }
廣播通知

  類似 pthread_cond_broadcast() 的功能。利用從已關閉的 channel 讀取數據時總是非阻塞的特性,可以實現在一個協程中向其他多個協程廣播某個事件發生的通知:

 1 package main
 2 
 3 import (
 4     "fmt"
 5     "time"
 6 )
 7 
 8 func main() {
 9     N := 10
10     exit := make(chan struct{})
11     done := make(chan struct{}, N)
12 
13     // start N worker goroutines
14     for i := 0; i < N; i++ {
15         go func(n int) {
16             for {
17                 select {
18                 // wait for exit signal
19                 case <-exit:
20                     fmt.Printf("worker goroutine #%d exit\n", n)
21                     done <- struct{}{}
22                     return
23                 case <-time.After(time.Second):
24                     fmt.Printf("worker goroutine #%d is working...\n", n)
25                 }
26             }
27         }(i)
28     }
29 
30     time.Sleep(3 * time.Second)
31     // broadcast exit signal
32     close(exit)
33     // wait for all worker goroutines exit
34     for i := 0; i < N; i++ {
35         <-done
36     }
37     fmt.Println("main goroutine exit")
38 }

3.2 信號量

  channel 的讀/寫相當於信號量的 P / V 操作,下面的示例程序中 channel 相當於信號量:

 1 package main
 2 
 3 import (
 4     "log"
 5     "math/rand"
 6     "time"
 7 )
 8 
 9 type Seat int
10 type Bar chan Seat
11 
12 func (bar Bar) ServeConsumer(customerId int) {
13     log.Print("-> consumer#", customerId, " enters the bar")
14     seat := <-bar // need a seat to drink
15     log.Print("consumer#", customerId, " drinks at seat#", seat)
16     time.Sleep(time.Second * time.Duration(2+rand.Intn(6)))
17     log.Print("<- consumer#", customerId, " frees seat#", seat)
18     bar <- seat // free the seat and leave the bar
19 }
20 
21 func main() {
22     rand.Seed(time.Now().UnixNano())
23 
24     bar24x7 := make(Bar, 10) // the bar has 10 seats
25     // Place seats in an bar.
26     for seatId := 0; seatId < cap(bar24x7); seatId++ {
27         bar24x7 <- Seat(seatId) // none of the sends will block
28     }
29 
30     // a new consumer try to enter the bar for each second
31     for customerId := 0; ; customerId++ {
32         time.Sleep(time.Second)
33         go bar24x7.ServeConsumer(customerId)
34     }
35 }

3.3 互斥量

  互斥量相當於二元信號里,所以 cap 為 1 的 channel 可以當成互斥量使用:

 1 package main
 2 
 3 import "fmt"
 4 
 5 func main() {
 6     mutex := make(chan struct{}, 1) // the capacity must be one
 7 
 8     counter := 0
 9     increase := func() {
10         mutex <- struct{}{} // lock
11         counter++
12         <-mutex // unlock
13     }
14 
15     increase1000 := func(done chan<- struct{}) {
16         for i := 0; i < 1000; i++ {
17             increase()
18         }
19         done <- struct{}{}
20     }
21 
22     done := make(chan struct{})
23     go increase1000(done)
24     go increase1000(done)
25     <-done; <-done
26     fmt.Println(counter) // 2000
27 }

4. 關閉 channel

  關閉不再需要使用的 channel 並不是必須的。跟其他資源比如打開的文件、socket 連接不一樣,這類資源使用完后不關閉後會造成句柄泄露,channel 使用完后不關閉也沒有關係,channel 沒有被任何協程用到后最終會被 GC 回收。關閉 channel 一般是用來通知其他協程某個任務已經完成了。golang 也沒有直接提供判斷 channel 是否已經關閉的接口,雖然可以用其他不太優雅的方式自己實現一個:

1 func isClosed(ch chan int) bool {
2     select {
3     case <-ch:
4         return true
5     default:
6     }
7     return false
8 }

  不過實現一個這樣的接口也沒什麼必要。因為就算通過 isClosed() 得到當前 channel 當前還未關閉,如果試圖往 channel 里寫數據,仍然可能會發生 panic ,因為在調用 isClosed() 后,其他協程可能已經把 channel 關閉了。
關閉 channel 時應該注意以下準則:

  • 不要在讀取端關閉 channel ,因為寫入端無法知道 channel 是否已經關閉,往已關閉的 channel 寫數據會 panic ;
  • 有多個寫入端時,不要再寫入端關閉 channle ,因為其他寫入端無法知道 channel 是否已經關閉,關閉已經關閉的 channel 會發生 panic ;
  • 如果只有一個寫入端,可以在這個寫入端放心關閉 channel 。

  關閉 channel 粗暴一點的做法是隨意關閉,如果產生了 panic 就用 recover 避免進程掛掉。稍好一點的方案是使用標準庫的 sync 包來做關閉 channel 時的協程同步,不過使用起來也稍微複雜些。下面介紹一種優雅些的做法。

4.1 一寫多讀

  這種場景下這個唯一的寫入端可以關閉 channel 用來通知讀取端所有數據都已經寫入完成了。讀取端只需要用 for range 把 channel 中數據遍歷完就可以了,當 channel 關閉時,for range 仍然會將 channel 緩衝中的數據全部遍歷完然後再退出循環:

 1 package main
 2 
 3 import (
 4     "fmt"
 5     "sync"
 6 )
 7 
 8 func main() {
 9     wg := &sync.WaitGroup{}
10     ch := make(chan int, 100)
11 
12     send := func() {
13         for i := 0; i < 100; i++ {
14             ch <- i
15         }
16         // signal sending finish
17         close(ch)
18     }
19 
20     recv := func(id int) {
21         defer wg.Done()
22         for i := range ch {
23             fmt.Printf("receiver #%d get %d\n", id, i)
24         }
25         fmt.Printf("receiver #%d exit\n", id)
26     }
27 
28     wg.Add(3)
29     go recv(0)
30     go recv(1)
31     go recv(2)
32     send()
33 
34     wg.Wait()
35 }

4.2 多寫一讀

  這種場景下雖然可以用 sync.Once 來解決多個寫入端重複關閉 channel 的問題,但更優雅的辦法設置一個額外的 channel ,由讀取端通過關閉來通知寫入端任務完成不要再繼續再寫入數據了:

 1 package main
 2 
 3 import (
 4     "fmt"
 5     "sync"
 6 )
 7 
 8 func main() {
 9     wg := &sync.WaitGroup{}
10     ch := make(chan int, 100)
11     done := make(chan struct{})
12 
13     send := func(id int) {
14         defer wg.Done()
15         for i := 0; ; i++ {
16             select {
17             case <-done:
18                 // get exit signal
19                 fmt.Printf("sender #%d exit\n", id)
20                 return
21             case ch <- id*1000 + i:
22             }
23         }
24     }
25 
26     recv := func() {
27         count := 0
28         for i := range ch {
29             fmt.Printf("receiver get %d\n", i)
30             count++
31             if count >= 1000 {
32                 // signal recving finish
33                 close(done)
34                 return
35             }
36         }
37     }
38 
39     wg.Add(3)
40     go send(0)
41     go send(1)
42     go send(2)
43     recv()
44 
45     wg.Wait()
46 }

4.2 多寫多讀

  這種場景稍微複雜,和上面的例子一樣,也需要設置一個額外 channel 用來通知多個寫入端和讀取端。另外需要起一個額外的協程來通過關閉這個 channel 來廣播通知:

 1 package main
 2 
 3 import (
 4     "fmt"
 5     "sync"
 6     "time"
 7 )
 8 
 9 func main() {
10     wg := &sync.WaitGroup{}
11     ch := make(chan int, 100)
12     done := make(chan struct{})
13 
14     send := func(id int) {
15         defer wg.Done()
16         for i := 0; ; i++ {
17             select {
18             case <-done:
19                 // get exit signal
20                 fmt.Printf("sender #%d exit\n", id)
21                 return
22             case ch <- id*1000 + i:
23             }
24         }
25     }
26 
27     recv := func(id int) {
28         defer wg.Done()
29         for {
30             select {
31             case <-done:
32                 // get exit signal
33                 fmt.Printf("receiver #%d exit\n", id)
34                 return
35             case i := <-ch:
36                 fmt.Printf("receiver #%d get %d\n", id, i)
37                 time.Sleep(time.Millisecond)
38             }
39         }
40     }
41 
42     wg.Add(6)
43     go send(0)
44     go send(1)
45     go send(2)
46     go recv(0)
47     go recv(1)
48     go recv(2)
49 
50     time.Sleep(time.Second)
51     // signal finish
52     close(done)
53     // wait all sender and receiver exit
54     wg.Wait()
55 }

  channle 作為 golang 最重要的特性,用起來還是比較方便的。傳統的 C 里要實現類似的功能的話,一般需要用到 socket 或者 FIFO 來實現,另外還要考慮數據包的完整性與併發衝突的問題,channel 則屏蔽了這些底層細節,使用者只需要考慮讀寫就可以了。 channel 是引用類型,了解一下 channel 底層的機制對更好的使用 channel 還是很用必要的。雖然操作原語簡單,但涉及到阻塞的問題,使用不當可能會造成死鎖或者無限制的協程創建最終導致進程掛掉。

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

【其他文章推薦】

※專營大陸空運台灣貨物推薦

台灣空運大陸一條龍服務

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

彰化搬家費用,南投搬家費用,距離,噸數怎麼算?達人教你簡易估價知識!

電子廢棄物回收會議在菲登場 台美菲合作

摘錄自2018年9月24日中央社報導

台灣、美國與菲律賓環境暨天然資源部合作舉辦的「第8屆國際電子廢棄物回收管理夥伴會議」(The 8th International E-waste Management Network Workshop)24日在菲律賓奎松市(Quezon City)Seda Vertis大酒店開幕,為期五天,來自全球5大洲的11個夥伴國家逾50位專家學者參與,交流各國電子廢棄物管理經驗。行政院環境保護署以資源回收基金補貼業者,以此建立回收處理體系的成功經驗,在這次會議中成為各國諮詢的焦點。

環保署表示,透過多年宣揚,現在已有馬來西亞參考台灣資源回收制度,推動家用電子廢棄物回收試辦計畫,隨後也宣布將參考台灣家用電子廢棄物的管理模式及制度,成立基金管理會,是台灣環保政策輸出國外的成功案例。

這場會議,目的在提升全球電子廢棄物回收處理環境無害化的管理能力,由台灣行政院環境保護署與美國環境保護署贊助。

本站聲明:網站內容來源環境資訊中心https://e-info.org.tw/,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※專營大陸空運台灣貨物推薦

台灣空運大陸一條龍服務

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

彰化搬家費用,南投搬家費用,距離,噸數怎麼算?達人教你簡易估價知識!

能自轉的 GeoOrbital 電動車輪,顛覆你對電動腳踏車的印象

電動腳踏車的研發至今已好幾十年,多年來的成就不僅讓使用者能輕鬆爬坡,也減輕了許多不必要的疲勞,更是許多腳踏車廠商的兵家必爭之地。但對於腳踏車愛好者與收藏家來說,想騎電動卻又得重買一台電動腳踏車,真的是相當麻煩,家裡可能也沒多的空間放另一台腳踏車,那麼 GeoOrbital 電動車輪一定相當符合你的胃口。   GeoOrbital 車輪的設計概念相當簡單,他們並不打算與以往的電動腳踏車相同,像他們一樣把馬達與電池內建在腳踏車上,也不是要設計一個能另外在腳踏車上裝的裝置讓車輪轉,他們要的,是將電動馬達跟電池內建在腳踏車的輪子裡,如此一來輪子一拆就能走到哪用到哪,適用於各式各樣的腳踏車上。   GeoOrbital 電動車輪的外型類似於三角形,其中兩角是為穩定車身,另一角則放了能驅使車輪滾動的轉輪。GeoOrbital 車輪還附有可拆式電池,充電方式也相當方便,若使用者有需要的話還提供 USB 插槽供使用者充手機。此外,安裝方式也相當簡單,使用者只要將自己腳踏車的前輪拆下,把這電動車輪再裝上去,並將控制器安裝在把手上後,前後大約只要花上 60 秒就能安心上路。  

▲ GeoOrbital Wheel 在 Kickstarter 上開始募資。(Source:)   GeoOrbital 預估這款電動車輪最快的行駛速度最高可達每小時 32 公里,在使用者完全沒踩踏板的情況下,最遠也可達 32 公里,但若搭配使用者自行騎腳踏車和下坡的時候,這也是同時為 GeoOrbital 重新充電,如此一來最遠更可達 80 公里。對於一般把騎腳踏車當作休閒活動的使用者來說,這是相當綽綽有餘的。   然而,一般的車輪重量大約只有 6 磅,但若換上電動車輪後就會增加大約 5 到 11 磅(2 至 5 公斤左右)的重量,重量看似增加許多卻也不減消費者對 GeoOrbital 電動車輪的興趣。近日在群募網站 Kickstarter 上推出不到幾天的時間,最低的 499 與 599 美金早鳥優惠就已瞬間一掃而空,更以極為迅速的時間內就已累積超過群募成功的金額,可見消費者對全新概念的電動車輪相當買單。

(首圖來源:)    (本文授權轉載自《》─〈〉)  

本站聲明:網站內容來源於EnergyTrend https://www.energytrend.com.tw/ev/,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※專營大陸空運台灣貨物推薦

台灣空運大陸一條龍服務

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

彰化搬家費用,南投搬家費用,距離,噸數怎麼算?達人教你簡易估價知識!

Spring框架學習筆記(7)——Spring Boot 實現上傳和下載

最近忙着都沒時間寫博客了,做了個項目,實現了下載功能,沒用到上傳,寫這篇文章也是順便參考學習了如何實現上傳,上傳和下載做一篇筆記吧

下載

主要有下面的兩種方式:

  • 通過ResponseEntity 實現
  • 通過寫HttpServletResponse的OutputStream實現

我只測試了ResponseEntity<InputStreamResource>這種方法可行,另外一種方法請各位搜索資料。

我們在controller層中,讓某個方法返回ResponseEntity,之後,用戶打開這個url,就會直接開始下載文件

這裏,封裝了一個方法export,負責把File對象轉為ResponseEntity

public ResponseEntity<FileSystemResource> export(File file) {
    if (file == null) {
        return null;
    }
    HttpHeaders headers = new HttpHeaders();
    headers.add("Cache-Control", "no-cache, no-store, must-revalidate");
    headers.add("Content-Disposition", "attachment; filename=" + System.currentTimeMillis() + ".xls");//以時間命名文件,防止出現文件存在的情況,根據實際情況修改,我這裡是返回一個xls文件
    headers.add("Pragma", "no-cache");
    headers.add("Expires", "0");
    headers.add("Last-Modified", new Date().toString());
    headers.add("ETag", String.valueOf(System.currentTimeMillis()));

    return ResponseEntity
            .ok()
            .headers(headers)
            .contentLength(file.length())
            .contentType(MediaType.parseMediaType("application/octet-stream"))
            .body(new FileSystemResource(file));
}

Controller

@RequestMapping("download")
public ResponseEntity<FileSystemResource> downloadFile() {
    return export(new FIle());//這裏返回調用export的結果
}

上傳

1.配置

spring boot使用上傳功能,得先進行配置,spring boot配置方式有兩種,一種是資源文件properties配置,另外一種方式則是yml配置

properties配置:

## MULTIPART (MultipartProperties)
# 開啟 multipart 上傳功能
spring.servlet.multipart.enabled=true
# 文件寫入磁盤的閾值
spring.servlet.multipart.file-size-threshold=2KB
# 最大文件大小
spring.servlet.multipart.max-file-size=200MB
# 最大請求大小
spring.servlet.multipart.max-request-size=215MB

yml配置:

spring:
    servlet:
        multipart:
          enabled: true # 開啟 multipart 上傳功能
          max-file-size: 200MB # 最大文件大小
          max-request-size: 215MB # 最大文件請求大小
          file-size-threshold: 2KB # 文件寫入磁盤的閾值

2.編寫url請求

controller

@PostMapping("/upload")
@ResponseBody
public String upload(@RequestParam("file") MultipartFile file) {
    if (file.isEmpty()) {
        return "上傳失敗,請選擇文件";
    }

    String fileName = file.getOriginalFilename();
    String filePath = "/Users/itinypocket/workspace/temp/";//文件上傳到服務器的路徑,根據實際情況修改
    File dest = new File(filePath + fileName);
    try {
        file.transferTo(dest);
        LOGGER.info("上傳成功");
        return "上傳成功";
    } catch (IOException e) {
        LOGGER.error(e.toString(), e);
    }
    return "上傳失敗!";
}

3.Web頁面上傳文件

注意,input標籤的name與url的請求參數名相同,上傳只能使用post請求
單個文件上傳:

<form method="post" action="/upload" enctype="multipart/form-data">
    <input type="file" name="file"><br>
    <input type="submit" value="提交">
</form>

多個文件上傳:

input標籤加上multiple屬性,即可一次選擇多個文件

<form method="post"  action="/upload" enctype="multipart/form-data">
    <input type="file" multiple name="file"><br>
    <input type="submit" value="提交">
</form>

4.Android端上傳文件

使用okhttp上傳文件

RequestBody filebody = RequestBody.create(MediaType.parse("application/octet-stream"), file);
RequestBody body = new MultipartBody.Builder()
        .addFormDataPart("file", file.getName(), filebody)
        .build();
Request request = new Request.Builder()
        .url("http://192.168.1.106:8080/webapp/fileUploadPage")
        .post(body)
        .build();

Call call = okHttpClient.newCall(request);
call.enqueue(new Callback() {
    @Override
    public void onFailure(Call call, IOException e) {
        Log.e(TAG, "請求失敗:" + e.getMessage());
    }

    @Override
    public void onResponse(Call call, Response response) throws IOException {
        Log.e(TAG, "請求成功!");
    }
});

參考鏈接:

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

【其他文章推薦】

※專營大陸空運台灣貨物推薦

台灣空運大陸一條龍服務

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

彰化搬家費用,南投搬家費用,距離,噸數怎麼算?達人教你簡易估價知識!

萬向電動車有望2017年進入中國市場

日前,有媒體報導稱,萬向收購菲斯科之後的首款車型將命名為Karma Revero,將由萬向旗下的Karma公司在美國生產,計畫7月或8月正式亮相,年底前開始銷售。如果不出意外,大約到2017年,將以進口方式正式進入中國市場銷售。

雖然這款車的價格還沒有確定,但是其競爭對手應該就是特斯拉的Model 3。

萬向製造的首款電動乘用車不僅將競爭對手指向特斯拉,其銷售模式也有望複製特斯拉。目前,萬向正在考慮是否使用直銷的模式來進行銷售。

同時,萬向還模仿特斯拉的管理手段,從通用等跨國公司挖掘高管,負責產品研發、財務、行銷等部門。據瞭解,目前,萬向在美國加州建設的電動車工廠,已進入生產線的試運行階段,將於6月投產。

靜待生產資質

萬向之所以在美國建廠生產,不僅是為兌現收購菲斯科時的承諾,而且也是無奈之舉。

資料顯示,萬向能夠順利收購菲斯科,是因為其在向美國政府提出的《復興計畫》中明確,將在美國建廠解決一些當地就業問題。

更重要的是,目前,萬向並沒有獲得在國內生產電動乘用車的生產資質。

實際上,萬向收購A123和菲斯科後,其轉型計畫就已啟動,在先後獲得專用車和客車生產資質後,電動專用車和電動客車已投入使用。業內有觀點認為,雖然製造電動乘用車和電動商用車有一定差距,但在供應鏈方面可以實現部分共用。

同時,有消息稱,此前萬向已製造了少量電動乘用車,並在杭州試運行,運行的資料和資料也會成為萬向電動乘用車量產的重要支撐。

由此來看,未來,萬向國內工廠的生產條件,以及依託A123電池技術、菲斯科車身技術、寶馬動力總成技術打造的電動車能夠獲得我國相關部門的認可,獲得電動乘用車生產資質,其電動乘用車計畫也將快速成型。

本站聲明:網站內容來源於EnergyTrend https://www.energytrend.com.tw/ev/,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※專營大陸空運台灣貨物推薦

台灣空運大陸一條龍服務

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

彰化搬家費用,南投搬家費用,距離,噸數怎麼算?達人教你簡易估價知識!