精华内容
下载资源
问答
  • 可以测网速的工具。
  • C层实现多线程测网速

    千次阅读 2013-09-06 09:02:40
    可能这个程序有很问题,所以请各位大婶批评指正,勿喷!   Server端: #include #include #include #include #include #include #include #include #include #include   #define BUFSIZE 1024 ...

    可能这个程序有很多问题,所以请各位大婶批评指正,勿喷!

     

    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类型的时候,是不是会影响运行速度?

     

     

     


     

     

     

    展开全文
  • NetSpeedTest Android测试网速的APP 把2个开源代码整合了一下,然后改改了。组成了这个利用多线程下载的测试...由于多线程下载 一次分块后没有后续的调度 为了保证满线程负载下拿速度 所以下载源比较大 而且只15秒
  • 多线程测速软件带宽叠加设置

    千次阅读 2017-05-02 14:41:00
    线路负载方式为TX+RX并且开启线路附加轮询 转载于:https://www.cnblogs.com/sysk/p/6796048.html

    线路负载方式为TX+RX并且开启线路附加轮询

    转载于:https://www.cnblogs.com/sysk/p/6796048.html

    展开全文
  • 编写多线程并发的测试

    千次阅读 2017-09-24 11:27:21
    在实际运用的过程中,我们经常遇到一些场景需要测试我们接口的并发能力。 案例: 1.一个抽奖接口,在奖品被抽完后总不能还继续中到此奖品吧,万一是iphone等大奖,那就悲剧需要写邮件反省了。 2.一个下订单接口...

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


    案例:

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



    展开全文
  • 1、多线程下载 2、可以设置是否开启断点继续下载(为了保护磁盘,默认关闭) 多线程下载原理 假如把文件比作成一个水缸,我们要从水缸把水取出来,单线程就是插一根水管接水,那么多线程就是插很多根管子同时接水。...

    引言

    多线程是多任务的一种特别的形式,但多线程使用了更小的资源开销。
    多线程能满足程序员编写高效率的程序来达到充分利用 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();
    

    最后效果如下:
    在这里插入图片描述

    展开全文
  • 联想网速测试工具是一款十分不错的网速检测软件,软件主要是以赛车的形式为您显示测试到的网速,...电脑怎么测试网速? 1、打开360安全卫士,然后点击“功能大全”的更按钮; 2、就能看到“宽带测速器”的图标; 3、
  • 多线程和单线程速度

    2019-05-09 00:37:00
    多线程不一定比单线程速度快,只有在特定的场景下,多线程才能发挥优势。 例如数据库的存储,单线程速度就比多线程快。 多线程适用于复杂任务,并发任务,往往响应需要一定的时间,这时候通过调用多个线程,同时处理...
  • 测网速工具

    2012-11-26 14:59:12
    最专业的网络测速软件,看他们运营商还敢不敢欺骗你网络带宽的事实
  • 客户端同时向服务器端发起30个连接线程,以5Mbps为数据发送速率: [root@linuxcool ~]#iperf -u -c 192.168.1.1 -b 100M -d -t 60 在tcp模式下,客户端到服务器192.168.1.1上传带宽测试测试时间为60秒: [r
  • iPerf 测试网速的小教训

    千次阅读 2016-07-06 11:47:27
    光纤,SPF,交换机端口,VLAN, iBGP的设定等等都严格按照ISP的要求,最后升级完成以后,豆子做iPerf做了个网速测试。在我看来,iperf的测试应该很简单,在一端机器上运行 ipferf.exe -s 监听,另外一端运行iperf.exe...
  • 单线程和多线程是什么意思 ?

    千次阅读 2017-05-26 11:38:06
    多线程是指程序中包含多个执行流,即在一个程序中可以同时运行多个不同的线程来执行不同的任务; 单线程就只有一个执行流;
  • linux网速测试

    千次阅读 2019-03-04 16:44:00
    linux网速测试 2019年03月04日 系统版本:CentOS Linux release 7.5.1804 参考文档 https://jingyan.baidu.com/article/f006222814b0eefbd2f0c873.html linux命令行界面用 speedtest 测网速,linux版本是基于...
  • 通过上面的示例我们大家应该都发现了,网络检查Job任务是一个单线程执行的,如果在任务数不多的情况下执行效率还可以接受,一旦任务数比较多,那么如何通过C#多线程技术来实现我们的多任务同时并行操作呢,从而提高...
  • Java多线程下载文件

    万次阅读 热门讨论 2017-08-03 10:03:08
    Java多线程下载文件优化:合理利用服务器资源,将资源利用最大化,加快下载速度一般有两种方式: 线程池里面有N个线程,多线程下载单个文件,将网络路径的文件流切割成多快,每个线程下载一小部分,然后写入到文件...
  • Python 爬虫提速:【多进程、多线程、协程+异步】对比测试概念介绍测试环境开始测试测试【单线程单进程】测试【多进程 并行】测试多线程 并发】测试【协程 + 异步】结果对比 Python 爬虫提速:【多进程、多线程、...
  • 把一个文件下载流分成 n 份,即 n 个线程各下载一份 等待所有线程搞定,之后将 n 个文件合并为一个 实例 以下载 QQ2020 PC为例 ,大小82MB 留意HTTP协议,先查看下它的HTTP response 文件类型是octet-stream ,...
  • 多线程下载   多线程下载时,由于多个线程在竞争实时可用带宽。尽管多线程逻辑上是并行的,但其实还是按时序的串行处理。所以每个线程处于的阶段并不一致。并且带宽资源是固定的。   比如使用3个线程来进行下载...
  • iperf3平台网速测速

    千次阅读 2020-10-31 21:57:10
    文章目录网卡测试一. 简介二. 关于iperf三. iperf安装四. 硬件判断网卡五. iperf3的使用六. 总结 网卡测试 一. 简介 不知道大家有没有这样的需求,测试你的pc网卡是千兆的还是百兆的,在实际传输数据的时候速度能跑...
  • 多线程发布测试

    2011-03-11 19:51:07
    多线程发布测试
  • 多线程IP开放端口检测源码,源码是用内网测试,当然外网页可以测试出同样效果,检测的速度取决于您的电脑和网速
  • 该demo的多线程写磁盘的逻辑不好,有待修正,哈哈,但是3-2的测试还是有意义的; ⚠️: 这个demo并没有生产意义,因为数据都是写入同一个文件,所以最终还是串行写入,磁头在各个磁盘来回寻道,也许不但不会提高...
  • 线程 面试官:线程和进程的区别是什么?...1.多线程,java语言内置了多线程的支持,实际上一个java程序就是一个jvm进程,jvm进程用一个主要的线程来执行main()方法,在main()方法内部,我们又可以启动多个
  • 上网速度测试App的界面和功能都比较简单测速结果偏慢从测试结果来看,这款上网速度测试App出的结果偏慢,测试数次结果类同。也许是因为服务器在国外吧。上网速度测试App并不能准确反映出国...
  • 看了就会:多线程下载图片并压缩,多线程下载能提高效率吗? 前言 又来更新了,得空记录下之前写得一个需求,欢迎大佬前来指教,轻喷???? 需求 导出Excel:本身以为是一个简单得导出,但是每行得记录文件中有一列为...
  • 前言 需求 导出Excel:本身以为是一个简单得...多线程实现使用了线程池,Jdk1.8并发包下的CompletableFuture 第一步:得到基础数值 // 线程数 Integer threadNum = 10; // 每条线程需要处理的图片数 int d
  • python爬虫:短代码实现多线程爬虫

    千次阅读 2017-07-07 16:56:01
    现在关于python多线程爬虫的文章并不少见,但是很多代码冗长,逻辑混乱,也有很多代码在博主实际测试之后发现已经无法使用,都不太适合新接触爬虫的同志们学习,所以我在这里贴一个我写的用python多线程爬虫爬斗图网...
  • 准备 最近神经网络研究遇到了一点瓶颈,于是想着琢磨点其他的东西缓冲一下,正好那天遇到了一些关于...考虑到多线程,那得利用open函数里的**seek()**去指定每个线程负责写入那一块数据,然后大家一起工作最好就拼凑...
  • 多线程

    2021-02-19 19:55:38
    1.创建线程的开销远远小于创建进程 ...进程之间是竞争关系 : 不同的应用程序开启的不同进程共同争夺计算机硬件资源(cpu、网卡(网速)等) 线程之间是协作关系 : 同一个进程内的线程都是协作关系, 一个线程将数据处理交
  • 多线程基础知识梳理

    2020-03-19 16:08:44
    多线程–Java中一种最基本的并发模型 文章目录多线程--Java中一种最基本的并发模型1.多线程基础:"同时"运行多个任务2.创建新线程:继承Thread或实现Runnable3.线程的状态:start()与run()4.中断线程:调用interrupt...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,521
精华内容 2,208
关键字:

多线程测网速