精华内容
下载资源
问答
  • Java实现多线程画图

    千次阅读 2018-11-02 22:48:36
    Java实现多线程画图 目录 功能分析 初步实现 添加监听器 创建多线程 实现多线程画图 1,功能分析 这个程序的基本思路就是:展示一个JFrame界面,给JFrame添加我们自己实现的鼠标事件监听器,记录鼠标...

    用Java实现多线程画图

    目录

    1. 功能分析
    2. 初步实现
    3. 添加监听器
    4. 创建多线程
    5. 实现多线程画图

    1,功能分析

    这个程序的基本思路就是:展示一个JFrame界面,给JFrame添加我们自己实现的鼠标事件监听器,记录鼠标事件点击时鼠标所在坐标;JFrame类提供了一个getGraphics()方法可以得到java.awt.Graphics对象,Graphics可以理解为“画布”对象,通过调用Graphics对象不同的Draw方法并传入鼠标的坐标参数,就可以在JFrame界面上画出相应的图形;最后,利用Runnable接口为程序添加多线程。

    2,初步实现

    package 画球;
    import java.awt.Graphics;
    import javax.swing.*;
    public class Draw {
    	public static void main(String[] args) {
    		Draw d = new Draw();
     		d.showUI();
    	}
    	public void showUI(){
    		JFrame jf = new JFrame();
    		jf.setTitle("画板");
    		jf.setSize(800, 500);
    		jf.setResizable(false); 
    		jf.setDefaultCloseOperation(3);
    		jf.setVisible(true);
    		Graphics g = jf.getGraphics();
    		}
    }
    

    3,添加监听器

    创建一个新的类DrawListener用于写监听器,这里用的是鼠标事件监听器,可以在查看鼠标事件监听器的声明

    声明我们这里重写鼠标事件监听器的mouseReased方法,当鼠标松开时,在当前位置画一个圆。

    package 画球;
    import java.awt.Graphics;
    import java.awt.event.MouseEvent;
    import java.awt.event.MouseListener;
    import javax.swing.JFrame;
    public class DrawListener implements MouseListener{
    	 public int x1,x2,y1,y2;
    	 public int pre=0,now=1;
    	 private Graphics g;
    	 public boolean f = false;
    	 public DrawListener(Graphics g){
    	  this.g = g;
    	 }
    	public void mouseClicked(MouseEvent e){
    	}
    	public void mousePressed(MouseEvent e){ 
    	}
    	public void mouseReleased(MouseEvent e){
    	x1 = e.getX();
    	y1 = e.getY();
    	g.fillOval(x1-25, y1-25, 50, 50);
    	}
    	public void mouseEntered(MouseEvent e){ 
    	}
    	public void mouseExited(MouseEvent e){  
    	}
    }
    

    4,创建多线程

    需要注意的是要将Graphics和坐标传进来

    package 画球;
    import java.awt.Graphics;
    public class Run implements Runnable {
    	private Graphics g;
    	public int x1, y1;
    	public Run(Graphics g, int x1, int y1) {
    		this.g = g;
    		this.x1 = x1;
    		this.y1 = y1;
    	}
    	public void run() {
    		int i = 0;
    		while (true) {
    			g.fillOval(x1 - 25 + i, y1 - 25, 50, 50);
    			try {
    				Thread.sleep(40);
    			} catch (InterruptedException e1) {
    			e1.printStackTrace();
    			}
    			i++;
    		}
    	}
    }
    

    最后在监听器的mouseReased方法中创建多线程并在主程序中添加监听器

    Run r = new Run(g,x1,y1);
    new Thread(r,"1").start();
    
    DrawListener dl = new DrawListener(g);
    jf.addMouseListener(dl);
    

    5,实现多线程画图

    运行程序

    画板

    随便点击几个点,出现同时运行的线程

    在这里插入图片描述

    在这里插入图片描述

    展开全文
  • Java 实现多线程的四种方式

    万次阅读 2020-09-19 22:06:34
    Java实现多线程一共有四种方式: 继承 Thread 类 实现 Runnable 接口 实现 Callable 接口 线程池 下面我将对这四种方式进行入门级的解析和演示。 一、继承 Thread 类 通过继承 Thread 类实现多线程的步骤...

    在 Java 中实现多线程一共有四种方式:

    1. 继承 Thread 类
    2. 实现 Runnable 接口
    3. 实现 Callable 接口
    4. 线程池

    下面我将对这四种方式进行入门级的解析和演示。

    一、继承 Thread 类

    通过继承 Thread 类实现多线程的步骤如下:

    1. 创建 MyThread 类,让其继承 Thread 类并重写 run() 方法。
    2. 创建 MyThread 类的实例对象,即创建一个新线程。
    3. 调用 start() 方法,启动线程。

    代码示例如下:

    public class MyThread extends Thread {
        @Override
        public void run() {
            System.out.println("我是通过继承 Thread 类创建的多线程,我叫" + Thread.currentThread().getName());
        }
    }
    
    class TestMyThread {
        public static void main(String[] args) {
            MyThread myThread1 = new MyThread();
            myThread1.setName("Thread-1");
            MyThread myThread2 = new MyThread();
            myThread2.setName("Thread-2");
            MyThread myThread3 = new MyThread();
            myThread3.setName("Thread-3");
    
            myThread1.start();
            myThread2.start();
            myThread3.start();
        }
    }
    

    为了演示线程执行顺序的随机性,我特意创建了三个线程,并为每一个线程命名,下面是我运行五次程序的执行结果:

    // 第一次
    我是通过继承 Thread 类创建的多线程,我叫Thread-2
    我是通过继承 Thread 类创建的多线程,我叫Thread-1
    我是通过继承 Thread 类创建的多线程,我叫Thread-3
    
    // 第二次
    我是通过继承 Thread 类创建的多线程,我叫Thread-1
    我是通过继承 Thread 类创建的多线程,我叫Thread-3
    我是通过继承 Thread 类创建的多线程,我叫Thread-2
    
    // 第三次
    我是通过继承 Thread 类创建的多线程,我叫Thread-1
    我是通过继承 Thread 类创建的多线程,我叫Thread-3
    我是通过继承 Thread 类创建的多线程,我叫Thread-2
    
    // 第四次
    我是通过继承 Thread 类创建的多线程,我叫Thread-1
    我是通过继承 Thread 类创建的多线程,我叫Thread-2
    我是通过继承 Thread 类创建的多线程,我叫Thread-3
    
    // 第五次
    我是通过继承 Thread 类创建的多线程,我叫Thread-2
    我是通过继承 Thread 类创建的多线程,我叫Thread-1
    我是通过继承 Thread 类创建的多线程,我叫Thread-3
    

    从上面的执行结果我们可以看到线程的执行顺序和代码中编写的顺序没有关系,线程的执行顺序是具有随机性的。

    二、实现 Runnable 接口

    Runnable 接口只有一个 run() 方法,源码如下:

    public interface Runnable {
        public abstract void run();
    }
    

    通过实现 Runnable 接口实现多线程的步骤如下:

    1. 创建 MyRunnable 类实现 Runnable 接口。
    2. 创建 MyRunnable 类的实例对象 myRunnable 。
    3. 把实例对象 myRunnable 作为参数来创建 Thread 类的实例对象 thread,实例对象 thread 就是一个新线程。
    4. 调用 start() 方法,启动线程。

    代码示例如下:

    public class MyRunnable implements Runnable {
        @Override
        public void run() {
            System.out.println("我是通过实现 Runnable 接口创建的多线程,我叫" + Thread.currentThread().getName());
        }
    }
    
    class TestMyRunnable {
        public static void main(String[] args) {
            MyRunnable myRunnable = new MyRunnable();
            Thread thread = new Thread(myRunnable);
            thread.start();
        }
    }
    

    执行结果如下:

    我是通过实现 Runnable 接口创建的多线程,我叫Thread-0
    

    相比于继承 Thread 类的方法来说,实现 Runnable 接口是一个更好地选择,因为 Java 不支持多继承,但是可以实现多个接口。

    有一点值得注意的是 Thread 类也实现了 Runnable 接口,这意味着构造函数 Thread(Runnable target) 不仅可以传入 Runnable 接口的对象,而且可以传入一个 Thread 类的对象,这样就可以将一个 Thread 对象中的 run() 方法交由其他线程进行调用。

    三、实现 Callable 接口

    Callable 接口只有一个 call() 方法,源码如下:

    public interface Callable<V> {
        V call() throws Exception;
    }
    

    从源码我们可以看到 Callable 接口和 Runnable 接口类似,它们之间的区别在于 run() 方法没有返回值,而 call() 方法是有返回值的。

    通过实现 Callable 接口实现多线程的步骤如下:

    1. 创建 MyCallable 类实现 Callable 接口。
    2. 创建 MyCallable 类的实例对象 myCallable。
    3. 把实例对象 myCallable 作为参数来创建 FutureTask 类的实例对象 futureTask。
    4. 把实例对象 futureTask 作为参数来创建 Thread 类的实例对象 thread,实例对象 thread 就是一个新线程。
    5. 调用 start() 方法,启动线程。

    代码示例如下:

    public class MyCallable implements Callable<Integer> {
        @Override
        public Integer call() throws Exception {
            int a = 6;
            int b = 9;
            System.out.println("我是通过实现 Callable 接口创建的多线程,我叫" + Thread.currentThread().getName());
            return a + b;
        }
    }
    
    class TestMyCallable {
        public static void main(String[] args) throws ExecutionException, InterruptedException {
            MyCallable myCallable = new MyCallable();
            FutureTask<Integer> futureTask = new FutureTask(myCallable);
            Thread thread = new Thread(futureTask);
            thread.start();
            System.out.println("返回值为:" + futureTask.get());
        }
    }
    

    执行结果如下:

    我是通过实现 Callable 接口创建的多线程,我叫Thread-0
    返回值为:15
    

    FutureTask 类提供了一个 get() 方法用来获取 call() 方法的返回值,但需要注意的是调用这个方法会导致程序阻塞,必须要等到线程结束后才会得到返回值。

    四、线程池

    在 Java 中构建一个新的线程是需要一定的系统开销的,前面三种实现多线程的方法在线程执行完任务后就会将线程销毁,那么是否可以在线程执行完任务后将线程保存下来,给下一个任务使用呢?答案是可以的,为了解决这个问题,线程池应运而生。

    顾名思义,线程池就是用来存储线程的池子。线程池中包含许多准备运行的线程,我们只需要为线程池提供一个个任务,线程池就会按照一定的规则去调用这些任务,当一个任务完成后,调用这个任务的线程不会死亡,而是留在线程池中准备为下一个任务提供服务。

    Executors 类提供了许多静态工厂方法用来构造线程池,这里我介绍其中的三种:

    1. newFixedThreadPool(int nThreads)

      该方法用来构造一个固定大小的线程池,空闲的线程会一直保留着,如果提交的任务数多于空闲线程数,就会把未得到服务的任务放到队列中等待。

      代码示例如下:

      public class MyFixedThreadPool {
          public static void main(String[] args) throws ExecutionException, InterruptedException {
              ExecutorService executorService = Executors.newFixedThreadPool(3);
              // 调用 Runnable 任务
              TestRunnable1 testRunnable1 = new TestRunnable1();
              for (int i = 0; i < 5; i++) {
                  // 调用 Runnable 任务可以用以下两种方法,二者的区别在于前者没返回值,后者有返回值
                  executorService.execute(testRunnable1);
                  Future<?> submit = executorService.submit(testRunnable1);
              }
              // 调用 Callable 任务
              TestCallable1 testCallable1 = new TestCallable1();
              for (int i = 0; i < 5; i++) {
                  // 调用 Callable 任务只能用这一种方法
                  Future<Integer> submit = executorService.submit(testCallable1);
                  System.out.println("返回值:" + submit.get());
              }
          }
      }
      
      class TestRunnable1 implements Runnable {
          @Override
          public void run() {
              System.out.println("我是 Runnable 任务,调用我的线程是:" + Thread.currentThread().getName());
          }
      }
      
      class TestCallable1 implements Callable<Integer> {
          @Override
          public Integer call() throws Exception {
              System.out.println("我是 Callable 任务,调用我的线程是:" + Thread.currentThread().getName());
              return 666;
          }
      }
      
    2. newCachedThreadPool()

      该方法构建的线程池会立即执行任务,如果当前存在空闲线程,则直接执行任务;如果当前不存在空闲线程,则创建一个新线程执行任务。在该线程池内的空闲线程只会保留 60 秒。

      public class MyCachedThreadPool {
          public static void main(String[] args) throws ExecutionException, InterruptedException {
              ExecutorService executorService = Executors.newCachedThreadPool();
              // 调用 Runnable 任务
              TestRunnable2 testRunnable2 = new TestRunnable2();
              for (int i = 0; i < 5; i++) {
                  // 调用 Runnable 任务可以用以下两种方法,二者的区别在于前者没返回值,后者有返回值
                  executorService.execute(testRunnable2);
                  Future<?> submit = executorService.submit(testRunnable2);
              }
              // 调用 Callable 任务
              TestCallable2 testCallable2 = new TestCallable2();
              for (int i = 0; i < 5; i++) {
                  // 调用 Callable 任务只能用这一种方法
                  Future<Integer> submit = executorService.submit(testCallable2);
                  System.out.println("返回值:" + submit.get());
              }
          }
      }
      
      class TestRunnable2 implements Runnable {
          @Override
          public void run() {
              System.out.println("我是 Runnable 任务,调用我的线程是:" + Thread.currentThread().getName());
          }
      }
      
      class TestCallable2 implements Callable<Integer> {
          @Override
          public Integer call() throws Exception {
              System.out.println("我是 Callable 任务,调用我的线程是:" + Thread.currentThread().getName());
              return 666;
          }
      }
      
    3. newSingleThreadExecutor()

      该方法构建的线程池只存在一个线程,会顺序地执行所提交的任务。

      public class MySingleThreadExecutor {
          public static void main(String[] args) throws ExecutionException, InterruptedException {
              ExecutorService executorService = Executors.newSingleThreadExecutor();
              // 调用 Runnable 任务
              TestRunnable3 testRunnable3 = new TestRunnable3();
              for (int i = 0; i < 5; i++) {
                  // 调用 Runnable 任务可以用以下两种方法,二者的区别在于前者没返回值,后者有返回值
                  executorService.execute(testRunnable3);
                  Future<?> submit = executorService.submit(testRunnable3);
              }
              // 调用 Callable 任务
              TestCallable3 testCallable3 = new TestCallable3();
              for (int i = 0; i < 5; i++) {
                  // 调用 Callable 任务只能用这一种方法
                  Future<Integer> submit = executorService.submit(testCallable3);
                  System.out.println("返回值:" + submit.get());
              }
          }
      }
      
      class TestRunnable3 implements Runnable {
          @Override
          public void run() {
              System.out.println("我是 Runnable 任务,调用我的线程是:" + Thread.currentThread().getName());
          }
      }
      
      class TestCallable3 implements Callable<Integer> {
          @Override
          public Integer call() throws Exception {
              System.out.println("我是 Callable 任务,调用我的线程是:" + Thread.currentThread().getName());
              return 666;
          }
      }
      
    展开全文
  • Java实现多线程的三种方式

    千次阅读 多人点赞 2020-02-02 11:03:20
    Java中可通过三种方式来实现多线程:1、继承Thread类,重写run( )方法;2、实现Runnable接口,重写run( )方法;3、实现Callable接口,重写call( )方法并使用FutureTask获取call( )方法的返回结果

    C语言自学完备手册(33篇)

    Android多分辨率适配框架

    JavaWeb核心技术系列教程

    HTML5前端开发实战系列教程

    MySQL数据库实操教程(35篇图文版)

    推翻自己和过往——自定义View系列教程(10篇)

    走出思维困境,踏上精进之路——Android开发进阶精华录

    讲给Android程序员看的前端系列教程(40集免费视频教程+源码)


    版权声明

    • 本文原创作者:谷哥的小弟
    • 作者博客地址:http://blog.csdn.net/lfdfhl

    概述

    在Java中可通过三种方式来实现多线程:

    • 1、继承Thread类,重写run( )方法
    • 2、实现Runnable接口,重写run( )方法
    • 3、实现Callable接口,重写call( )方法并使用FutureTask获取call( )方法的返回结果

    利用Thread类实现多线程

    主要步骤

    • 1、通过继承Thread创建线程的子类
    • 2、重写Thread类的run( )方法
    • 3、创建子类实例对象
    • 4、调用子类实例对象start( )方法启动线程

    使用示例

    package com.thread1;
    /**
     * 本文作者:谷哥的小弟 
     * 博客地址:http://blog.csdn.net/lfdfhl
     */
    public class ThreadCreate1 {
    
    	public static void main(String[] args) {
    		//创建第一个子线程
    		MyThread firstThread=new MyThread();
    		firstThread.start();
    		String firstThreadName = firstThread.getName();
    		System.out.println("firstThreadName="+firstThreadName);
    		
    		//创建第二个子线程
    		MyThread secondThread=new MyThread();
    		secondThread.start();
    		String secondThreadName = secondThread.getName();
    		System.out.println("secondThreadName="+secondThreadName);
    	}
    
    }
    
    //MyThread继承Thread类
    class MyThread extends Thread{
    	@Override
    	public void run() {
    		super.run();
    		String threadName = Thread.currentThread().getName();
    		for(int i=0;i<5;i++) {
    			System.out.println(threadName+",i="+i);
    		}
    	}
    }
    
    

    运行结果

    在这里插入图片描述

    利用Runnable接口实现多线程

    主要步骤

    • 1、创建Runnable接口实现类并重写该接口的run( )方法
    • 2、创建Runnable接口实现类对象
    • 3、利用Thread有参构造函数public Thread(Runnable target)和Runnable接口实现类对象创建线程实例
    • 4、调用线程实例的start( )方法启动线程

    使用示例

    package com.thread1;
    /**
     * 本文作者:谷哥的小弟 
     * 博客地址:http://blog.csdn.net/lfdfhl
     */
    public class ThreadCreate2 {
    
    	public static void main(String[] args) {
    		// 创建第一个子线程
    		MyRunnable firstMyRunnable=new MyRunnable();
    		Thread firstThread = new Thread(firstMyRunnable);
    		firstThread.start();
    		String firstThreadName = firstThread.getName();
    		System.out.println("firstThreadName=" + firstThreadName);
    
    		// 创建第二个子线程
    		MyRunnable secondMyRunnable=new MyRunnable();
    		Thread secondThread = new Thread(secondMyRunnable);
    		secondThread.start();
    		String secondThreadName = secondThread.getName();
    		System.out.println("secondThreadName=" + secondThreadName);
    	}
    
    }
    
    //MyRunnable实现Runnable接口
    class MyRunnable implements Runnable {
    	@Override
    	public void run() {
    		String threadName = Thread.currentThread().getName();
    		for (int i = 0; i < 5; i++) {
    			System.out.println(threadName + ",i=" + i);
    		}
    	}
    
    }
    
    

    运行结果

    在这里插入图片描述

    利用Callable接口实现多线程

    主要步骤

    • 1、创建Callable接口实现类并重写该接口的call( )方法
    • 2、创建Callable接口实现类对象
    • 3、使用Runnable子类FutureTask的有参构造函数public FutureTask(Callable< V > callable)和Callable接口实现类对象创建FutureTask实例
    • 4、利用Thread有参构造函数public Thread(Runnable target)和FutureTask实例创建线程实例
    • 5、调用线程实例的start( )方法启动线程
    • 6、利用FutureTask的get( )方法获取子线程执行结果

    使用示例

    package com.thread1;
    
    import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.FutureTask;
    /**
     * 本文作者:谷哥的小弟 
     * 博客地址:http://blog.csdn.net/lfdfhl
     */
    public class ThreadCreate3 {
    
    	public static void main(String[] args) throws InterruptedException, ExecutionException {
    		// 创建第一个子线程
    		MyCallable firstMyCallable = new MyCallable();
    		FutureTask<Object> firstFutureTask = new FutureTask<>(firstMyCallable);
    		Thread firstThread = new Thread(firstFutureTask);
    		firstThread.start();
    		String firstThreadName = firstThread.getName();
    		System.out.println("firstThreadName=" + firstThreadName);
    		// 获取第一个子线程返回的结果
    		Object firstThreadResult = firstFutureTask.get();
    		System.out.println("firstThreadResult=" + firstThreadResult);
    
    		// 创建第二个子线程
    		MyCallable secondMyCallable = new MyCallable();
    		FutureTask<Object> secondFutureTask = new FutureTask<>(secondMyCallable);
    		Thread secondThread = new Thread(secondFutureTask);
    		secondThread.start();
    		String secondThreadName = secondThread.getName();
    		System.out.println("secondThreadName=" + secondThreadName);
    		// 获取第二个子线程返回的结果
    		Object secondThreadResult = secondFutureTask.get();
    		System.out.println("secondThreadResult=" + secondThreadResult);
    	}
    
    }
    
    // MyCallable实现Callable接口
    class MyCallable implements Callable<Object> {
    	@Override
    	public Object call() throws Exception {
    		String threadName = Thread.currentThread().getName();
    		int i = 0;
    		while (i < 5) {
    			System.out.println(threadName + ",i=" + i);
    			i++;
    		}
    		return i;
    	}
    
    }
    
    

    运行结果

    在这里插入图片描述

    总结

    为避免Java单继承带来的局限性,在实际开发中多采用实现Runnable接口或实现Callable接口的方式实现多线程。

    展开全文
  • Java实现多线程爬虫

    千次阅读 2019-04-09 17:35:45
    给定一个网址,获取该网站中所有的图片(重要的,图标哪些就不算了),实现多线程下载,自动爬取。 我做的项目爬取的是孔夫子二手书官网的计算机类的所有书籍的图片:http://item.kongfz.com/Cjisuanji/ 知识储备 ...

    项目介绍

    该项目是《网络程序设计》老师布置的一个作业,让完成:
    	给定一个网址,获取该网站中所有的图片(重要的,图标哪些就不算了),实现多线程下载,自动爬取。
    	我做的项目爬取的是孔夫子二手书官网的计算机类的所有书籍的图片:http://item.kongfz.com/Cjisuanji/
    

    知识储备

    开发步骤

    分析源代码

    在这里插入图片描述

    	分析发现,所有书都存在与id=”listBox“中,每个书的class=”item clearfix“,所以可以使用jsoup的getElementById获取到所有书,然后使用getElementByClass获取书的列表,循环获取每本书。
    	而书的图片放在了class="img-box"的a标签中的img标签中,可以使用先到达a标签,然后使用getElementByTag()获取img,获取后的attr("src")就是图片的url。
    

    源码

    • 主程序(CrawlImage.java)
    package crawlimage;
    import java.util.*;
    import java.io.*;
    //引入线程池的包
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    //引入jsoup的包
    import org.jsoup.Jsoup;
    import org.jsoup.nodes.Document;
    import org.jsoup.nodes.Element;
    import org.jsoup.select.Elements;
    
    
    public class CrawImage {
        
        public static void getUrl(Document document,ExecutorService pool){
            Element id = document.getElementById("listBox");
                Elements els = id.getElementsByTag("img");
                
                for(Element el : els){
                    //url.add(el.attr("src"));
                    String imageUrl = el.attr("src");
                    pool.execute(new DownloadImage(imageUrl));
                    System.out.println(el.attr("src"));
                }
                
        }
        public static void main(String[] args) throws Exception{
            //Set<String> url = new TreeSet<>();
            try{
                //创建一个缓冲池
                ExecutorService pool = Executors.newCachedThreadPool();
                //设置其容量为9
                pool = Executors.newFixedThreadPool(9);
                
                //获取指定网页源码
                Document document = Jsoup.connect("http://item.kongfz.com/Cjisuanji/w2/").userAgent("Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.31 (KHTML, like Gecko) Chrome/26.0.1410.64 Safari/537.31").get();
                getUrl(document,pool);
                int a = 4;
                while(a--!=0){
                    Element el = document.getElementById("pagerBox");
                    Elements el2 = el.getElementsByClass("next-btn");
                    if(el2 == null){
                        System.out.println("到最后了");
                        break;
                    }
                    String urlIndex = el2.attr("href");
                    Document document2 = Jsoup.connect(urlIndex).userAgent("Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.31 (KHTML, like Gecko) Chrome/26.0.1410.64 Safari/537.31").get();
                    getUrl(document2,pool);
                }
                
                //遍历set中图片的url
    //            for(String imageUrl:url){
    //                pool.execute(new DownloadImage(imageUrl));
    //            }
                pool.shutdown();
                
            }catch(Exception e){
                System.out.print(e);
            }
        }
        
    }
    
    • 多线程下载程序(DownloadImage.java)

        package crawlimage; 
        import java.io.*;
        import java.net.*;
        
        public class DownloadImage implements Runnable{
            String downUrl;
            public DownloadImage(String downUrl){
                this.downUrl = downUrl;
            }
            public void run(){
                BufferedInputStream bis = null;
                FileOutputStream fos = null;
                try{
                    //生成url对象
                    URL url = new URL(downUrl);
                    //创建urlconnection对象
                    URLConnection uc = url.openConnection();
                    //获取uc的输入流
                    bis = new BufferedInputStream(uc.getInputStream());
                    //创建图片的存储对象
                    String[] p = downUrl.split("/");
                    String path = "F:\\test\\"+p[p.length-1];
                    fos = new FileOutputStream(path);
                    int c;
                    while((c=bis.read())!=-1){
                        fos.write(c);
                    }            
                }catch(Exception e){
                    System.out.println(e);
                }finally{
                    try{
         if(bis!=null){
             bis.close();
         }
      
         if(fos!=null){
             fos.close();
         }
         }catch(Exception e){
             System.out.println("没办法了");
         }
        }
        }
        }
      
    展开全文
  • 需求中需要查询多个SQL...但是使用并行的方式进行查询,即多线程查询,所消耗的时间为查询最久SQL的时间。 此处使用callable + furtherTask 方式实现 Callable<List<Map<String, String>>> ma...
  • java实现多线程(车站卖票)

    万次阅读 多人点赞 2019-07-30 16:03:15
    import java.util.ArrayList;...public class 多线程 { // public static int j=0; public static long a=0; public static void main(String[] args) throws InterruptedException { List&l...
  • Java实现多线程的三种方式及其特点

    千次阅读 2018-09-06 16:24:26
    关于实现多线程有多种方式,这里列举常用的三种方式:继承Thread类、实现Runnable接口、实现Callable接口。  下面是三种实现方式: 继承java.lang.Thread //实现多线程的第一种方式 class MyThread extends ...
  • Java实现多线程轮流打印1-100的数字

    万次阅读 多人点赞 2019-03-25 20:49:43
    首先打印1-100数字如果用一个单线程实现那么只要一个for循环即可,那么如果要用两个线程打印出来呢?(一个线程打印奇数,一个线程打印偶数)于是大家会想到可以通过加锁实现,但是这样的效率是不是不高?这里我用一...
  • JAVA实现多线程任务执行框架

    千次阅读 2019-07-18 16:31:11
    很长时间没有写过文章了,因现在从事的JAVA方向的系统开发,所以独自写了一个基础的任务执行框架,目的是根据所需应用场景,定制系统实现任务。此处有借助公司的框架思想实现的。废话不说了,直接进入正题。 由于...
  • java实现多线程卖票

    千次阅读 2018-09-28 17:31:49
    java多线程卖票直接先看个例子: public class SelTicketsMainTest { public static void main(String[] args) { SaleTickets1 saleTickets = new SaleTickets1(); for(int t=1;t&lt;=3;t++) { new...
  • Java实现多线程服务器程序

    千次阅读 2011-11-09 02:21:31
    利用Java,编写安全高效的多线程程序变得简单,而且利用多线程和Java的网络包我们可以方便的实现多线程服务器程序。  ---- Java是伴随Internet的大潮产生的,对网络及多线程具有内在的支持,具有网络时代编程...
  • java实现多线程下载技术

    千次阅读 2013-03-11 22:11:32
    多线程下载技术,简单的说就是把要下载的文件分成几块,由不同的线程来负责每一块数据的下载任务。  要使用一个随机访问文件的类:RandomAccessFile类,具体用法请参考:...
  • Java实现多线程环境下的计数器功能

    千次阅读 2017-09-21 11:27:54
    上面这段代码如果在单线程环境没有问题,但是我们知道Servlet是多线程的,如果两个线程同时请求service,当线程1的count+1后,线程2进来了,这个时候count还是0,加1后得到的值还是1,这并不是我们想要的结果。...
  • 实现多线程的方式 --继承Thread类,重写run函数 --实现Runnable接口 --实现Callable接口三种方式的区别 --实现Runnable接口可以避免Java单继承特性而带来的局限;增强程序的健壮性,代码能够被多个线程共享,...
  • Java实现多线程下载和断点续传

    热门讨论 2010-04-02 22:20:14
    1. 把每个下载文件切成若干个块...2. HTTP Header里增加Range,如果服务器返回Cotent-Range 说明服务器支持文件定位,可以实现多线程下载 详细看这里 http://blog.csdn.net/maoxiang/archive/2010/04/02/5446293.aspx
  • Java实现多线程到底有多少种方法?

    千次阅读 2020-01-10 13:32:35
    可以去百度一下,答案有很。 到底有
  • 大致流程先将要写入文件的数据写入到一个队列中,然后单开一个线程专门读取队列数据写入文件,可以保证写入到文件的数据的顺序,生产者类即多线程写入文件模拟package com.ldl.test.domain; import java.text....
  • Java是伴随Internet的大潮产生的,对网络及多线程具有内在的支持,具有网络时代编程语言的一切特点。从Java的当前应用看,Java主要用于在Internet或局域网上的网络编程,而且将Java作为主流的网络编程语言的趋势...
  • 万字图解Java多线程

    万次阅读 多人点赞 2020-09-06 14:45:07
    java多线程我个人觉得是javaSe中最难的一部分,我以前也是感觉学会了,但是真正有多线程的需求却不知道怎么下手,实际上还是对多线程这块知识了解不深刻,不知道多线程api的应用场景,不知道多线程的运行流程等等,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 924,855
精华内容 369,942
关键字:

java实现多线程

java 订阅