可能这个程序有很多问题，所以请各位大婶批评指正，勿喷！
 
 
 
Server端：
 
#include<pthread.h>
 #include<stdio.h>
 #include<sys/types.h>
 #include<sys/socket.h>
 #include<netinet/in.h>
 #include<arpa/inet.h>
 #include <fcntl.h>
 #include <errno.h> 
 #include <sys/stat.h>
 #include<time.h>
 
 
 
#define BUFSIZE 1024
 
pthread_t thread[4];
 

 double sock(int port){
  int server_sockfd;
  int client_sockfd;
  struct sockaddr_in server_addr;
  struct sockaddr_in client_addr;
  int sin_size;
  char buf[BUFSIZE];
  
  memset(&server_addr, 0, sizeof(server_addr)); 
  server_addr.sin_family=AF_INET;
  server_addr.sin_addr.s_addr=INADDR_ANY;
  server_addr.sin_port=htons(port);
  
  if((server_sockfd=socket(PF_INET,SOCK_STREAM,0))<0){
   perror("socket");
   return 1;
  } 
  if(bind(server_sockfd,(struct sockaddr *)&server_addr,sizeof(struct sockaddr))<0){
   perror("bind");
   return 1;
  }
  listen(server_sockfd,5);
  sin_size=sizeof(struct sockaddr_in);
  if((client_sockfd=accept(server_sockfd,(struct sockaddr *)&client_addr,&sin_size))<0){
   perror("accept");
   return 1;
  } 
  printf("accept client %s   port%d\n",inet_ntoa(client_addr.sin_addr),port);
  int buflen=128*1024;
  setsockopt(client_sockfd,SOL_SOCKET,SO_RCVBUF,(const char *)&buflen,sizeof(int));
  unsigned long count=0;
  unsigned int length;
  clock_t start,finish;
  start=clock();
  while((length=recv(client_sockfd,buf,BUFSIZE,0))>0){
   if(length<0){
    printf("receive failed!");
    break;
   }
   count+=length;
  }
  finish=clock();
  printf("The total count of byte is %ld bytes\n",count);
  double time=(double)(finish-start)/CLOCKS_PER_SEC;
  double v=(double)(count)/1024/time;
  printf("v = %lf KB/s \n",v);
  return v;
 } 
 double v1,v2,v3,v4;
 void *thread1()
 {
  v1=sock(8000);
  pthread_exit(NULL);
 }
 
void *thread2()
 {
  v2=sock(8001);
  pthread_exit(NULL);
 }
 void *thread3()
 {
  v3=sock(8002);
  pthread_exit(NULL);
 }
 void *thread4()
 {
  v4=sock(8003);
  pthread_exit(NULL);
 }
 void thread_create(void)
 {
  int temp;
  memset(&thread,0,sizeof(thread));
  if((temp=pthread_create(&thread[0],NULL,thread1,NULL))!=0)
   printf("creating thread1 failed!\n");
  else
   printf("creating thread1 success!\n");
  if((temp=pthread_create(&thread[1],NULL,thread2,NULL))!=0)
   printf("creating thread2 failed!\n");
  else
   printf("creating thread2 success!\n");
  if((temp=pthread_create(&thread[2],NULL,thread3,NULL))!=0)
   printf("creating thread3 failed!\n");
  else
   printf("creating thread3 success!\n");  
  if((temp=pthread_create(&thread[3],NULL,thread4,NULL))!=0)
   printf("creating thread4 failed!\n");
  else
   printf("creating thread4 success!\n");  
 }
 void thread_wait(void)
 {
  if(thread[0]!=0)
  {
   pthread_join(thread[0],NULL);
   printf("thread1 is finished!\n");
  }
  if(thread[1]!=0)
  {
   pthread_join(thread[1],NULL);
   printf("thread2 is finished!\n");
  }
  if(thread[3]!=0)
  {
   pthread_join(thread[3],NULL);
   printf("thread3 is finished!\n");
  }
  if(thread[4]!=0)
  {
   pthread_join(thread[4],NULL);
   printf("thread4 is finished!\n");
  }
 }
 
int main()
 {
  printf("I'm main function.I'm creating thread!\n");
  thread_create();
  printf("I'm main function.I'm waiting for thread to finish task!\n");
  thread_wait();
  printf("The total of vate is %lf KB/s\n",v1+v2+v3+v4);
  return 0;
 } 
 
 
 
 
 
 Client端：
 
 
 
#include<pthread.h>
 #include<stdio.h>
 #include<sys/time.h>
 #include<string.h>
 #include<sys/socket.h>
 #include<arpa/inet.h>
 #include<time.h>
 
#define filename "/sdcard/ssss.mp3"
 #define BUFSIZE 1024
 #define MAX 10
 #define TIMES 2500
 
pthread_t thread[4];
 int port1=0,port2=0,port3=0,port4=0;
 char* addr;
 
 
 
double sock(char* addr,char* port){
  int i=TIMES;
  int client_sockfd;
  struct sockaddr_in server_addr;
  char buf[BUFSIZE];
  memset(&server_addr,0,sizeof(server_addr));
  server_addr.sin_family=AF_INET;
  server_addr.sin_addr.s_addr=inet_addr(addr);
  server_addr.sin_port=htons(atoi(port));
  if((client_sockfd=socket(PF_INET,SOCK_STREAM,0))<0)
  {
   perror("socket");
   return 1;
  }
  printf("create client socket\n");
  
  int buflen=128*1024;
  setsockopt(client_sockfd,SOL_SOCKET,SO_SNDBUF,(const char *)&buflen,sizeof(int));
  
  if(connect(client_sockfd,(struct sockaddr *)&server_addr,sizeof(struct sockaddr))<0)
  {
   perror("connect");
   return 1;
  }
  printf("connected to server\n");
  
  FILE* from_fd;
  if((from_fd=fopen(filename,"r"))==-1) 
  { 
   printf("open or create file failed!"); 
   exit(0); 
  } 
  int len=fread(buf,sizeof(char),BUFSIZE,from_fd);
  
  clock_t start,finish;
  start=clock();
  while(i--){
   if(send(client_sockfd,buf,len,0)<0){
    printf("length<0\n");
    break;
   }
  } 
  finish=clock();
  double time=(double)(finish-start)/CLOCKS_PER_SEC;
  double v=TIMES/time;
  printf("v = %lf KB/s \n",v);
  return v;
 }
 double v1,v2,v3,v4;
 void *thread1()
 {
  v1=sock(addr,port1);
  pthread_exit(NULL);
 }
 
void *thread2()
 {
  v2=sock(addr,port2);
  pthread_exit(NULL);
 }
 void *thread3()
 {
  v3=sock(addr,port3);
  pthread_exit(NULL);
 }
 void *thread4()
 {
  v4=sock(addr,port4);
  pthread_exit(NULL);
 }
 void thread_create(void)
 {
  int temp;
  memset(&thread,0,sizeof(thread));
  if((temp=pthread_create(&thread[0],NULL,thread1,NULL))!=0)
   printf("creating thread1 failed!\n");
  else
   printf("creating thread1 success!\n");
  if((temp=pthread_create(&thread[1],NULL,thread2,NULL))!=0)
   printf("creating thread2 failed!\n");
  else
   printf("creating thread2 success!\n");
  if((temp=pthread_create(&thread[2],NULL,thread3,NULL))!=0)
   printf("creating thread3 failed!\n");
  else
   printf("creating thread3 success!\n");
  if((temp=pthread_create(&thread[3],NULL,thread4,NULL))!=0)
   printf("creating thread4 failed!\n");
  else
   printf("creating thread4 success!\n");
 }
 
void thread_wait(void)
 {
  if(thread[0]!=0)
  {
   pthread_join(thread[0],NULL);
   printf("thread1 is finished!\n");
  }
  if(thread[1]!=0)
  {
   pthread_join(thread[1],NULL);
   printf("thread2 is finished!\n");
  }
  if(thread[2]!=0)
  {
   pthread_join(thread[2],NULL);
   printf("thread3 is finished!\n");
  }
  if(thread[3]!=0)
  {
   pthread_join(thread[3],NULL);
   printf("thread4 is finished!\n");
  }
 }
 
int main(int argc,char *argv[])
 {
  addr=argv[1];
  port1=argv[2];
  port2=argv[3];
  port3=argv[4];
  port4=argv[5];
  
  printf("I'm main function.I'm creating thread!\n");
  thread_create();
  printf("I'm main function.I'm waiting for thread to finish task!\n");
  thread_wait();
  printf("The total of vate is %lf KB/s\n",v1+v2+v3+v4);
  exit(0);
 } 
 

  另外有个小问题，sock函数返回double类型的时候，是不是会影响运行速度？
 
 
 
 
 
 
 

  
 
 
 
 

 
 
线路负载方式为TX+RX并且开启线路附加轮询
 
 
转载于:https://www.cnblogs.com/sysk/p/6796048.html

在实际运用的过程中，我们经常遇到一些场景需要测试我们接口的并发能力。
 

 
 
案例：
 
 
1.一个抽奖接口，在奖品被抽完后总不能还继续中到此奖品吧，万一是iphone等大奖，那就悲剧需要写邮件反省了。
 
2.一个下订单接口，用户要是操作速度或者网速的原因导致两个请求同时到达服务器，难道就插入两条订单么？同样，说不定还得邮件反省。
 

 
 
事由：
 
1.集群分布式部署导致synchronized在接口中控制并发失效
 
2.redis分布式锁不稳定，而且锁时间限制不容易具体定值
 

 
 
解决办法：
 
1.结合spring自带事务特性与数据库的行级锁，悲观锁  for update，就是在查询某条记录的时候限制其他线程对其进行修改，知道本线程提交事务，此方法当然较为影响程序接口的性能，希望有更好办法的大神指导评论！
 

 
 
结论：
 
多线程并发在我们编码过程中是很重要的，如何做好并发防守也是一个程序员应该需要有的素养和技能。
 

 
 
怎么进行并发测试呢？junit不支持多线程并发测试呢？有什么其他工具么？有的这边就指出一个应付并发测试的工具类
 
1.导入依赖包
 
 
	<dependency>
		<groupId>net.sourceforge.groboutils</groupId>
		<artifactId>GroboTestingJUnit</artifactId>
		<version>1.2.1</version>
	</dependency>
2.怎么在测试类中使用呢？ 
 
 
@Transactional
@RunWith(SpringJUnit4ClassRunner.class)  
@ContextConfiguration(locations = {"classpath*:spring-conf/spring-*.xml"}) 
public class CashBackTest {
	//注入你要测试的业务类
	@Autowired
	private  TestService testService;

	@Test  
	@Transactional
    public void initTest(){  
		//Runner数组，想当于并发多少个。
        TestRunnable[] trs = new TestRunnable[20];
        for (int i = 0; i < 20; i++) {
            trs[i] = new MyHomeThread();
        }

        // 用于执行多线程测试用例的Runner，将前面定义的单个Runner组成的数组传入
        MultiThreadedTestRunner mttr = new MultiThreadedTestRunner(trs);

        // 开发并发执行数组里定义的内容
        try {
			mttr.runTestRunnables();
		} catch (Throwable e) {
			e.printStackTrace();
		}
	}
	
	 private class MyHomeThread extends TestRunnable {
	        @Override
	        public void runTest() throws Throwable {
				//编写调用你要测试的接口方法，执行一个调用
				testService.testMethold(params);
	        }
	 }
}


 
这个工具类是有点类似java的CountDownLatch似的，等到所有的线程都准备好才一起执行调用你要测试的方法，具体有兴趣的朋友可以去看一下这个工具类的源码，我这边就不多聊。有更好解决测试类测试并发接口的方法，欢迎广大猿友评论学习！ 
 
 

 
 

 
 

引言
 
多线程是多任务的一种特别的形式，但多线程使用了更小的资源开销。
 多线程能满足程序员编写高效率的程序来达到充分利用 CPU 的目的。
 
一个线程可以创建和撤销另一个线程；同一个进程中的多个线程之间可以并发执行。
 
相对进程而言，线程是一个更加接近于执行体的概念，它可以与同进程中的其他线程共享数据，但拥有自己的栈空间，拥有独立的执行序列。
 
在串行程序基础上引入线程和进程是为了提高程序的并发度，从而提高程序运行效率和响应时间。
 
实现功能
 
1、设置指定下载线程数
 2、可以设置是否开启断点继续下载(为了保护磁盘，默认关闭)
 3、下载进度展示
 4、网速展示
 
多线程下载原理
 
把网络中的文件分成若干块（下载线程数量），然后客户端开启子线程分别下载对应的区域。打个比方假如把文件比作成一个水缸，我们要从水缸把水取出来，单线程就是插一根水管接水，那么多线程就是插很多根管子同时接水。速度就可以大大的提升，当然，最大速度还是取决于你的网络带宽。
 
断点继续下载原理
 
下载文件的时候，把下载进度实时写入到本地临时文件储存，下次打开判断是否存在下载进度。
 
基本步骤
 
1、本地先创建一个大小跟服务器文件相同大小的临时文件
 
2、计算分配几个线程去下载服务器上的资源，知道每个线程下载文件的位置。文件的长度/3(线程个数)=得到每个线程下载文件的大小，假如文件长度为10
 线程1负责区域：0-2；
 线程2负责区域：3-5；
 线程3负责区域：6-文件末尾
 
每一个线程下载的起始位置计算方式
 开始位置：
 （线程id-1）每一块大小
 结束位置：
 （线程id每一块大小）-1
 
3、开启每一个线程下载对应位置的文件
 
4、如果所有的线程都把自己负责的区域下载完毕，那么就删除临时文件
 
代码实现
 
线程抽象类
 
import java.io.File;

/**
 * 线程下载抽象接口，增强了Runnable接口，主要增加下载断点开关
 */
public abstract class Downer implements Runnable {
    //开启是否断点下载，为了保护磁盘，默认关闭

    //文件下载地址
    private String url_path;
    //文件保存地址
    private String save_path;
    //下载进度保存位置，默认为C:\ProgramData
    private String temp_path="C:\\ProgramData\\";

    public String getTemp_path() {
        return temp_path;
    }

    public void setTemp_path(String temp_path) {
        this.temp_path = temp_path;
    }

    public Downer(String url_path, String save_path) {
        this.url_path = url_path;
        this.save_path = save_path;
    }

    public String getUrl_path() {
        return url_path;
    }

    public void setUrl_path(String url_path) {
        this.url_path = url_path;
    }
    public String getFileName(){
        return new File(save_path).getName();
    }
    public String getSave_path() {
        return save_path;
    }

    public void setSave_path(String save_path) {
        this.save_path = save_path;
    }

    public boolean bpDownload=false;

    public boolean isBpDownload() {
        return bpDownload;
    }

    public void setBpDownload(boolean bpDownload) {
        this.bpDownload = bpDownload;
    }
}
 
下载类，主要通过URL类的openConnection()方法对服务器发起请求，获取文件资源大小，分配各个子线程负责下载的区域；
 关于getResponseCode()方法返回的请求码说明：如果是请求服务器所有资源，返回值是200；如果请求服务器部分资源，比如多线程下载，那么返回值是206；
 
import java.io.RandomAccessFile;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.concurrent.ExecutorService;

/**
 * 多线程下载类
 */
public class ThreadDownload extends Downer{
    //线程下载数量，默认是1
    public static int threadCount=1;
    //记录各个子线程是否下载完毕，下载完一个减去1
    public static int runningThread=1;
    //文件总大小
    public volatile static int len=0;
    //文件进度
    public volatile static int progress;
    public ThreadDownload(String url_path, String save_path) {
        super(url_path, save_path);
    }

    public void setThreadCount(int threadCount){
        ThreadDownload.threadCount=threadCount;
        runningThread=threadCount;
    }
    @Override
    public void run() {
        try {
            URL url = new URL(getUrl_path());
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setConnectTimeout(100);
            conn.setRequestMethod("GET");
            if (conn.getResponseCode() == 200) {
                //服务器返回的数据的长度
                int length = conn.getContentLength();
                ThreadDownload.len=length;
                System.out.println(length);
                //在客户端本地创建一个大小跟服务器创建一个大小和服务器相等的临时文件
                RandomAccessFile raf = new RandomAccessFile(getSave_path(), "rwd");
                //指定创建的这个文件的长度
                raf.setLength(length);
                raf.close();
                //计算平均每个线程下载的文件的大小
                int blockSize = length /threadCount;
                for(int i=1;i<=threadCount;i++){
                    //第一个线程下载的开始位置
                    int startIndex=(i-1)*blockSize;
                    //结束位置
                    int endIndex=i*blockSize-1;
                    //最后一个线程结束位置是文件末尾
                    if(i==threadCount){
                        endIndex=length;
                    }
                    System.out.println("线程："+i+"下载"+startIndex+"--->"+endIndex);
                    SonThreadDownload sonThreadDownload = new SonThreadDownload(getUrl_path(), getSave_path());
                    sonThreadDownload.setBpDownload(this.isBpDownload());
                    sonThreadDownload.setter(i,startIndex,endIndex);
                    //这里使用了线程池，可以new Thread(sonThreadDownload).start();
                    //MyExecutorService.getThread().submit(sonThreadDownload);
                    new Thread(sonThreadDownload).start();
                }
                //开始监听下载进度
                speed();
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
        }
    }

    private void speed() {
        int temp=0;
        //循环监控网速，如果下载进度达到100%就结束监控
        while(ThreadDownload.progress!=ThreadDownload.len) {
            //System.out.println("ThreadDownload.progress="+ThreadDownload.progress+"--ThreadDownload.len="+ThreadDownload.len);
            temp=progress;

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //当前下载进度除以文件总长得到下载进度
            double p=(double)temp/(double)len*100;
            //当前下载进度减去前一秒的下载进度就得到一秒内的下载速度
            temp= progress-temp;

            //System.out.println(p);
            sl.speed(temp,p);
        }
        sl.speed(temp,100);
        System.out.println("整个文件下载完毕啦");
    }

    SpeedListener sl;
    /**
     * 
     * @param sl 网速监听回调接口
     */
    public void addSpeedListener(SpeedListener sl){
        this.sl=sl;
    }

}
 
下载进度和下载网速监听接口 SpeedListener .java
 
public interface SpeedListener {
    /**
     *
     * @param s 当前下载速度，单位字节
     * @param progress 下载进度，百分比
     */
    void speed(int s,double progress);
}

 
负责下载指定区域的子线程
 
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
/**
 * 负责下载上级分配的指定区域
 */
public class SonThreadDownload extends Downer{

    private int threadId;
    private int startIndex;
    private int endIndex;

    public SonThreadDownload(String url_path, String save_path) {
        super(url_path, save_path);
    }


    /**
     *
     * @param threadId 该线程下载id
     * @param startIndex 该线程下载开始位置
     * @param endIndex 该线程下载的结束位置
     */
    public void setter(int threadId,int startIndex,int endIndex){
        this.threadId=threadId;
        this.startIndex=startIndex;
        this.endIndex=endIndex;
    }
    @Override
    public void run() {
        InputStream is=null;
        RandomAccessFile raf=null;
        try {
            //检查是否存在记录下载长度的文件，如果存在就读取这个文件的数据
            File tempFile = new File(getTemp_path()+getFileName()+threadId + ".temp");
            //检查是否开启断点继续下载
            if(this.isBpDownload()&&tempFile.exists()&&tempFile.length()>0) {
                FileInputStream fis = new FileInputStream(tempFile);
                byte[] temp = new byte[1024];
                int leng = fis.read(temp);
                fis.close();
                String s = new String(temp, 0, leng);
                int dowloadlenInt = Integer.parseInt(s)-1;
                //修改下载的开始位置
                startIndex+=dowloadlenInt;
                //System.out.println(threadId+"线程真是开始位置："+startIndex);
            }

            URL url = new URL(getUrl_path());
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setConnectTimeout(100);
            conn.setRequestMethod("GET");
            //请求服务器下载部分文件的指定位置的位置
            conn.setRequestProperty("Range","bytes="+startIndex+"-"+endIndex);
            //请求服务器全部资源200ok，如果从服务器请求部分资源206ok
            int responseCode = conn.getResponseCode();
            if(responseCode==206){
                raf = new RandomAccessFile(getSave_path(), "rwd");
                is = conn.getInputStream();
                //定位文件从哪个位置开始写
                raf.seek(startIndex);
                int len=0;
                byte[] buff=new byte[1024*1024];
                //已经下载的数据长度
                int total=0;

                while((len=is.read(buff))!=-1){

                    raf.write(buff,0,len);
                    synchronized (ThreadDownload.class) {
                        ThreadDownload.progress += len;
                    }
                    total+=len;
                    if(isBpDownload()) {
                        //以文件名加线程id保存为临时文件，保存当前线程的下载进度
                        RandomAccessFile info = new RandomAccessFile(getTemp_path() + getFileName() + threadId + ".temp", "rwd");
                        info.write(String.valueOf(total + startIndex).getBytes());
                        info.close();
                    }
                }


            }
            System.out.println("线程："+threadId+"号下载完毕了");
            if(isBpDownload()) {
                synchronized (ThreadDownload.class) {
                    //下载中的线程--，当减到0时代表整个文件下载完毕，如果中途异常，那么这个文件就没下载完
                    ThreadDownload.runningThread--;
                    if (ThreadDownload.runningThread == 0) {
                        for (int i = 0; i < ThreadDownload.threadCount; i++) {
                            File file = new File(getTemp_path() + getFileName() + (i + 1) + ".temp");
                            file.delete();
                            System.out.println(getFileName() + (i + 1) + ".txt下载完毕，清除临时文件");
                        }

                    }
                }
            }

        } catch (Exception e) {
            e.printStackTrace();
            System.out.println(threadId+"号线程炸了");
        }finally {

            if(raf!=null){
                try {
                    raf.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(is!=null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

 
RandomAccessFile 类说明
 
jdk帮助文档中是这样说明的：
 此类的实例支持对随机访问文件的读取和写入。随机访问文件的行为类似存储在文件系统中的一个大型 byte 数组。存在指向该隐含数组的光标或索引，称为文件指针；输入操作从文件指针开始读取字节，并随着对字节的读取而前移此文件指针。如果随机访问文件以读取/写入模式创建，则输出操作也可用；输出操作从文件指针开始写入字节，并随着对字节的写入而前移此文件指针。写入隐含数组的当前末尾之后的输出操作导致该数组扩展。该文件指针可以通过 getFilePointer 方法读取，并通过 seek 方法设置。
 主要构造方法
 
 
 
RandomAccessFile(File file, String mode)
 创建从中读取和向其中写入（可选）的随机访问文件流，该文件由 File 参数指定。
 RandomAccessFile(String name, String mode)
 创建从中读取和向其中写入（可选）的随机访问文件流，该文件具有指定名称。
 
 
mode定义：mode 参数指定用以打开文件的访问模式。允许的值及其含意为：
 
值
含义
“r”
以只读方式打开。调用结果对象的任何 write 方法都将导致抛出 IOException。
“rw”
打开以便读取和写入。如果该文件尚不存在，则尝试创建该文件。
“rws”
打开以便读取和写入，对于 “rw”，还要求对文件的内容或元数据的每个更新都同步写入到底层存储设备。
“rwd”
打开以便读取和写入，对于 “rw”，还要求对文件内容的每个更新都同步写入到底层存储设备。
由于采用实时保存下载进度，怕万一中途断点啥的，在断点的前一秒把数据写入到磁盘保存时最安全的。
 
最后，再来一个测试类
 
		String game2="http://big.xiazaicc.com/bigfile/100/VB6.0qyb_downcc.com.zip";
        //1、连接服务器，获取一个文件，获取文件的长度，在本地创建一个大小跟服务器文件一样大的临时文件
        ThreadDownload threadDownload = new ThreadDownload(game2, "E:\\demo.zip");
        //设置线程数
        threadDownload.setThreadCount(15);
        //开启断点下载
        //threadDownload.setBpDownload(true);
        //添加进度和网速监听
        threadDownload.addSpeedListener(new SpeedListener() {
            @Override
            public void speed(int s, double progress) {
                String m=String.format("%.2f",(double) s/1024/1024);
                String pro=String.format("%.2f",progress);

                System.out.println(m+"m/s--进度："+pro+"%");
            }

        });
        //由于ThreadDownload类也是个线程类，可以开启线程
        threadDownload.run();
 
最后效果如下：