• 首页

    • java 一个线程处理多个任务

    因为是应用在Android手机上的,开启很多线程会造成APP反应很慢.所以想问下在java中有没有可能实现一个线程处理多个任务,比如我想用五条线程处理十个任务,因为每个任务的执行时间是很长的(超过半小时),有没有可能让一条线程同时执行两个任务,比如任务一执行5秒后将任务1暂停,然后执行任务2,执行5秒后再切换到任务1,这样循环直到两个任务都结束.java可以实现这样的效果吗?

    推荐答案   2015-10-15

    　　一个线程是只能执行一个任务，多个任务需要多线程处理。

    　　多线程将多任务的思想拓展到应用，因此，您可以将单个应用中的特定步骤进一步分解成一个个线程，每个线程可以并行运行。操作系统不仅在不同的应用任务间分配处理时间，而且在一项应用的每个线程间分配处理时间。

    　　工程与科学方面的应用程序通常运行于专用的系统（可能没有多任务化）。而一个多线程NI LabVIEW程序可以被分解成四个线程：用户界面、数据采集、网络通信以及数据录入。您可以分别赋予这四个线程的优先级，以便它们独立工作。于是，在多线程应用中，多项任务可以与该系统执行的其他应用并行执行。

    　　利用多线程的应用具有以下几大优势：

      更有效的CPU利用率

      更好的系统可靠性

      改善多处理器计算机的性能

    　　在许多应用中，您同步地调用资源，如仪器，这些仪器调用时常需要较长的时间完成。在一个单线程应用中，一个同步调用可能会阻止或防止该应用中的其他任务执行，直至该操作完成。而多线程避免了这样的情况出现。

    　　当同步调用在一个线程中运行时，程序中不依赖于该调用的其它部分可以在其它线程中运行。该程序的执行可以持续地推进，而不是停滞直到完成同步调用。这样，一个多线程应用实现了CPU使用效率的最大化，因为当该应用的所有线程都可以同时运行时，CPU不会处于空闲状态。

    温馨提示：答案为网友推荐，仅供参考
    其他回答
    第1个回答  2015-10-06
    线程是进程中的一个实体，是被系统独立调度和分派的基本单位。线程自己基本上不拥有系统资源，但它可以与同属一个进程的其他线程共享进程所拥有的全部资源。所以线程是轻量级的任务，它们之间的通信和转换只需要较小的系统开销。
    Java支持多线程编程，因此用Java编写的应用程序可以同时执行多个任务。Java的多线程机制使用起来非常方便，用户只需关注程序细节的实现，而不用担心后台的多任务系统。
    Java语言里，线程表现为线程类。Thread线程类封装了所有需要的线程操作控制。在设计程序时，必须很清晰地区分开线程对象和运行线程，可以将线程对象看作是运行线程的控制面板。在线程对象里有很多方法来控制一个线程是否运行，睡眠，挂起或停止。线程类是控制线程行为的唯一的手段。一旦一个Java程序启动后，就已经有一个线程在运行。可通过调用Thread.currentThread方法来查看当前运行的是哪一个线程。

    class ThreadTest{
    public static void main(String args[]){
    Thread t = Thread.currentThread();
    t.setName("单线程"); //对线程取名为"单线程"
    t.setPriority(8);
    //设置线程优先级为8，最高为10，最低为1，默认为5
    System.out.println("The running thread: " + t);
    // 显示线程信息
    try{
    for(int i=0;i<3;i++){
    System.out.println("Sleep time " + i);
    Thread.sleep(100); // 睡眠100毫秒
    }
    }catch(InterruptedException e){// 捕获异常
    System.out.println("thread has wrong");
    }
    }
    }

    多线程的实现方法
    继承Thread类
    可通过继承Thread类并重写其中的run()方法来定义线程体以实现线程的具体行为，然后创建该子类的对象以创建线程。
    在继承Thread类的子类ThreadSubclassName中重写run()方法来定义线程体的一般格式为:
    public class ThreadSubclassName extends Thread{
    public ThreadSubclassName(){
    ..... // 编写子类的构造方法，可缺省
    }
    public void run(){
    ..... // 编写自己的线程代码
    }
    }
    用定义的线程子类ThreadSubclassName创建线程对象的一般格式为:
    ThreadSubclassName ThreadObject =
    new ThreadSubclassName();
    然后，就可启动该线程对象表示的线程：
    ThreadObject.start(); //启动线程

    应用继承类Thread的方法实现多线程的程序。本程序创建了三个单独的线程，它们分别打印自己的“Hello World!”。
    class ThreadDemo extends Thread{
    private String whoami;
    private int delay;
    public ThreadDemo(String s,int d){
    whoami=s;
    delay=d;
    }
    public void run(){
    try{
    sleep(delay);
    }catch(InterruptedException e){ }
    System.out.println("Hello World!" + whoami
    + " " + delay);
    }
    }
    public class MultiThread{
    public static void main(String args[]){
    ThreadDemo t1,t2,t3;
    t1 = new ThreadDemo("Thread1",
    (int)(Math.random()*2000));
    t2 = new ThreadDemo("Thread2",
    (int)(Math.random()*2000));
    t3 = new ThreadDemo("Thread3",
    (int)(Math.random()*2000));
    t1.start();
    t2.start();
    t3.start();
    }
    }

    实现Runnable接口
    编写多线程程序的另一种的方法是实现Runnable接口。在一个类中实现Runnable接口(以后称实现Runnable接口的类为Runnable类),并在该类中定义run()方法，然后用带有Runnable参数的Thread类构造方法创建线程。
    创建线程对象可用下面的两个步骤来完成:
    (1)生成Runnable类ClassName的对象
    ClassName RunnableObject = new ClassName();
    (2)用带有Runnable参数的Thread类构造方法创建线程对象。新创建的线程的指针将指向Runnable类的实例。用该Runnable类的实例为线程提供 run()方法---线程体。
    Thread ThreadObject = new Thread(RunnableObject);
    然后，就可启动线程对象ThreadObject表示的线程：
    ThreadObject.start();
    在Thread类中带有Runnable接口的构造方法有:
    public Thread(Runnable target);
    public Thread(Runnable target, String name);
    public Thread(String name);
    public Thread(ThreadGroup group，Runnable target);
    public Thread(ThreadGroup group，Runnable target，
    String name);
    其中，参数Runnable target表示该线程执行时运行target的run()方法，String name以指定名字构造线程，ThreadGroup group表示创建线程组。
    用Runnable接口实现的多线程。
    class TwoThread implements Runnable{
    TwoThread(){
    Thread t1 = Thread.currentThread();
    t1.setName("第一主线程");
    System.out.println("正在运行的线程: " + t1);
    Thread t2 = new Thread(this,"第二线程");
    System.out.println("创建第二线程");
    t2.start();
    try{
    System.out.println("第一线程休眠");
    Thread.sleep(3000);
    }catch(InterruptedException e){
    System.out.println("第一线程有错");
    }
    System.out.println("第一线程退出");
    }
    public void run(){
    try{
    for(int i = 0;i < 5;i++){
    System.out.println(“第二线程的休眠时间：”
    + i);
    Thread.sleep(1000);
    }
    }catch(InterruptedException e){
    System.out.println("线程有错");
    }
    System.out.println("第二线程退出");
    }
    public static void main(String args[]){
    new TwoThread();
    }
    }
    程序运行结果如下：
    正在运行的线程: Thread[第一主线程,5,main
    创建第二线程
    第一线程休眠
    第二线程的休眠时间：0
    第二线程的休眠时间：1
    第二线程的休眠时间：2
    第一线程退出
    第二线程的休眠时间：3
    第二线程的休眠时间：4
    第二线程退出

    至于一个处理器同时处理多个程序，其实不是同时运行多个程序的，简单的说，如果是单核的CPU，在运行多个程序的时候其实是每个程序轮流占用CPU的，只是每个程序占用的时间很短，所以我们人为的感觉是“同时”运行多个程序。
    第2个回答  2014-12-20
    进程是程序在处理机中的一次运行。一个进程既包括其所要执行的指令，也包括了执行指令所需的系统资源，不同进程所占用的系统资源相对独立。所以进程是重量级的任务，它们之间的通信和转换都需要操作系统付出较大的开销。
    线程是进程中的一个实体，是被系统独立调度和分派的基本单位。线程自己基本上不拥有系统资源，但它可以与同属一个进程的其他线程共享进程所拥有的全部资源。所以线程是轻量级的任务，它们之间的通信和转换只需要较小的系统开销。
    Java支持多线程编程，因此用Java编写的应用程序可以同时执行多个任务。Java的多线程机制使用起来非常方便，用户只需关注程序细节的实现，而不用担心后台的多任务系统。
    Java语言里，线程表现为线程类。Thread线程类封装了所有需要的线程操作控制。在设计程序时，必须很清晰地区分开线程对象和运行线程，可以将线程对象看作是运行线程的控制面板。在线程对象里有很多方法来控制一个线程是否运行，睡眠，挂起或停止。线程类是控制线程行为的唯一的手段。一旦一个Java程序启动后，就已经有一个线程在运行。可通过调用Thread.currentThread方法来查看当前运行的是哪一个线程。

    class ThreadTest{
    public static void main(String args[]){
    Thread t = Thread.currentThread();
    t.setName("单线程"); //对线程取名为"单线程"
    t.setPriority(8);
    //设置线程优先级为8，最高为10，最低为1，默认为5
    System.out.println("The running thread: " + t);
    // 显示线程信息
    try{
    for(int i=0;i<3;i++){
    System.out.println("Sleep time " + i);
    Thread.sleep(100); // 睡眠100毫秒
    }
    }catch(InterruptedException e){// 捕获异常
    System.out.println("thread has wrong");
    }
    }
    }

    多线程的实现方法
    继承Thread类
    可通过继承Thread类并重写其中的run()方法来定义线程体以实现线程的具体行为，然后创建该子类的对象以创建线程。
    在继承Thread类的子类ThreadSubclassName中重写run()方法来定义线程体的一般格式为:
    public class ThreadSubclassName extends Thread{
    public ThreadSubclassName(){
    ..... // 编写子类的构造方法，可缺省
    }
    public void run(){
    ..... // 编写自己的线程代码
    }
    }
    用定义的线程子类ThreadSubclassName创建线程对象的一般格式为:
    ThreadSubclassName ThreadObject =
    new ThreadSubclassName();
    然后，就可启动该线程对象表示的线程：
    ThreadObject.start(); //启动线程

    应用继承类Thread的方法实现多线程的程序。本程序创建了三个单独的线程，它们分别打印自己的“Hello World!”。
    class ThreadDemo extends Thread{
    private String whoami;
    private int delay;
    public ThreadDemo(String s,int d){
    whoami=s;
    delay=d;
    }
    public void run(){
    try{
    sleep(delay);
    }catch(InterruptedException e){ }
    System.out.println("Hello World!" + whoami
    + " " + delay);
    }
    }
    public class MultiThread{
    public static void main(String args[]){
    ThreadDemo t1,t2,t3;
    t1 = new ThreadDemo("Thread1",
    (int)(Math.random()*2000));
    t2 = new ThreadDemo("Thread2",
    (int)(Math.random()*2000));
    t3 = new ThreadDemo("Thread3",
    (int)(Math.random()*2000));
    t1.start();
    t2.start();
    t3.start();
    }
    }

    实现Runnable接口
    编写多线程程序的另一种的方法是实现Runnable接口。在一个类中实现Runnable接口(以后称实现Runnable接口的类为Runnable类),并在该类中定义run()方法，然后用带有Runnable参数的Thread类构造方法创建线程。
    创建线程对象可用下面的两个步骤来完成:
    (1)生成Runnable类ClassName的对象
    ClassName RunnableObject = new ClassName();
    (2)用带有Runnable参数的Thread类构造方法创建线程对象。新创建的线程的指针将指向Runnable类的实例。用该Runnable类的实例为线程提供 run()方法---线程体。
    Thread ThreadObject = new Thread(RunnableObject);
    然后，就可启动线程对象ThreadObject表示的线程：
    ThreadObject.start();
    在Thread类中带有Runnable接口的构造方法有:
    public Thread(Runnable target);
    public Thread(Runnable target, String name);
    public Thread(String name);
    public Thread(ThreadGroup group，Runnable target);
    public Thread(ThreadGroup group，Runnable target，
    String name);
    其中，参数Runnable target表示该线程执行时运行target的run()方法，String name以指定名字构造线程，ThreadGroup group表示创建线程组。
    用Runnable接口实现的多线程。
    class TwoThread implements Runnable{
    TwoThread(){
    Thread t1 = Thread.currentThread();
    t1.setName("第一主线程");
    System.out.println("正在运行的线程: " + t1);
    Thread t2 = new Thread(this,"第二线程");
    System.out.println("创建第二线程");
    t2.start();
    try{
    System.out.println("第一线程休眠");
    Thread.sleep(3000);
    }catch(InterruptedException e){
    System.out.println("第一线程有错");
    }
    System.out.println("第一线程退出");
    }
    public void run(){
    try{
    for(int i = 0;i < 5;i++){
    System.out.println(“第二线程的休眠时间：”
    + i);
    Thread.sleep(1000);
    }
    }catch(InterruptedException e){
    System.out.println("线程有错");
    }
    System.out.println("第二线程退出");
    }
    public static void main(String args[]){
    new TwoThread();
    }
    }
    程序运行结果如下：
    正在运行的线程: Thread[第一主线程,5,main
    创建第二线程
    第一线程休眠
    第二线程的休眠时间：0
    第二线程的休眠时间：1
    第二线程的休眠时间：2
    第一线程退出
    第二线程的休眠时间：3
    第二线程的休眠时间：4
    第二线程退出

    至于一个处理器同时处理多个程序，其实不是同时运行多个程序的，简单的说，如果是单核的CPU，在运行多个程序的时候其实是每个程序轮流占用CPU的，只是每个程序占用的时间很短，所以我们人为的感觉是“同时”运行多个程序。本回答被提问者和网友采纳

    相关了解……

    你可能感兴趣的内容

    大家正在搜
    在java中怎样创建一个线程6个线程能开多少任务java实现多线程java多线程并发java多线程实例java多线程详解java 线程状态java 线程池Java 线程
    相关问题
    java启动多个线程执行同一个任务，效率会提高吗？
    java多线程任务一般开多少个线程
    java quartz每5分钟运行一次，几个小时后出现同一个...
    用java如何实现10个线程 一起完成15个任务（当一个线程...
    java 多线程是什么？一个处理器怎么同时处理多个程序
    JAVA中如何利用多线程同时运行多个方法？
    java 多线程同时执行一个任务 就像快车那种把任务分成几个...
    java 多个线程跑多个任务 去调不同的接口 怎么才能正确的...

    本站内容来自于网友发表，不代表本站立场，仅表示其个人看法，不对其真实性、正确性、有效性作任何的担保
    相关事宜请发邮件给我们
    © 非常风气网