`
OuYangGod
  • 浏览: 53764 次
  • 性别: Icon_minigender_1
  • 来自: 南京
社区版块
存档分类
最新评论

JAVA多线程(一)

阅读更多
Java多线程基础
1、实现线程的方式
  在Java中线程的实现无外乎两种方法:实现Runnable接口、继承Thread类:
  实现Runnable接口
public class MyTask implements Runnable
{

    @Override
    public void run()
    {
        System.out.println("mytask executed....");
    }

    public static void main(String[] args)
    {
        Thread t = new Thread(new MyTask());
        t.start();
        System.out.println("main complete.");
    }
}

  继承Thread类
public class MyTask2 extends Thread
{
    @Override
    public void run()
    {
        System.out.println("mytask2 executed....");
    }
    
    public static void main(String[] args)
    {
        Thread t = new MyTask2();
        t.start();
        System.out.println("main complete.");
    }
}

2、实现线程的变种方式
  Java的线程的实现方式还有很多变种,但都是基于上面的两种 方式的。
  使用内部类继承Thread类
public class InnerThread  
{  
    private Inner inner;  
      
    private class Inner extends Thread  
    {  
        @Override
        public void run()  
        {  
            System.out.println("inner task executed....");  
        }  
    }  
  
    public InnerThread()  
    {  
        inner = new Inner();
        inner.start();
    }  
      
    public static void main(String[] args)  
    {  
        InnerThread i = new InnerThread();  
        System.out.println("main complete.");  
    }  
}

  使用匿名内部类
public class AnonymousThread
{
    public AnonymousThread()
    {
        Thread t = new Thread(){
            @Override
            public void run()
            {
                System.out.println("anonymous task executed....");
            }
        };
        
        t.start();
    }
    
    public static void main(String[] args)
    {
        AnonymousThread i = new AnonymousThread();
        System.out.println("main complete.");
    }
}

  以上两个变种都是使用了Thread类,当然也可以使用Runnable接口,做法类似,在此就不举例子了。
3、Executors
  Java1.5引入了一些新的类,方便了对线程的管理,先看下面的例子
public class CachedThreadPool
{
    public static void main(String[] args)
    {
        ExecutorService exec = Executors.newCachedThreadPool();
        for (int i=0; i<5; i++)
        {
            exec.execute(new MyTask());
        }
        exec.shutdown();
        System.out.println("main complete.");
    }
    
}

class MyTask implements Runnable
{  
    static int counter = 0;
    private final int id = counter++;
    
    @Override
    public void run()
    {
        System.out.println("task[" + id + "] executed....");
    }
}

  在上面的例子中,并没有使用直接使用Thread类的start()方法执行线程,而是交给了Executor来管理线程的执行。

  Executors.newCachedThreadPool()方法创建一个ExecutorService(一个Executor的实现),Executor会为每个需要执行的任务创建一个线程并执行它;当Executor的shutdown()方法被调用后,就不能再把任务提交给Executor了,否则会报java.util.concurrent.RejectedExecutionException异常。

  除了CachedThreadPools,还有FixedThreadPools和SingleThreadExecutor。三者的区别非常简单,CachedThreadPools根据需要创建足够多的线程;FixedThreadPools在初始化的时候就创建好固定数目的线程;SingleThreadExecutor就像是大小为1的FixedThreadPools,同一时间只会有一个线程在执行。

  从下面的例子就可以看出来当有多个任务提交给SingleThreadExecutor时,这些任务将按照提交的顺序一个一个的执行;同样的道理也适合FixedThreadPools。
public class CachedThreadPool
{
    public static void main(String[] args)
    {
        ExecutorService exec = Executors.newSingleThreadExecutor();
        for (int i=0; i<5; i++)
        {
            exec.execute(new MyTask());
        }
        exec.shutdown();
        System.out.println("main complete.");
    }
    
}

class MyTask implements Runnable
{  
    static int counter = 0;
    private final int id = counter++;
    
    @Override
    public void run()
    {
        System.out.println("task[" + id + "] started....");
        Thread.currentThread().yield();
        System.out.println("task[" + id + "] completed....");
    }
}

  输出结果
task[0] started....
main complete.
task[0] completed....
task[1] started....
task[1] completed....
task[2] started....
task[2] completed....
task[3] started....
task[3] completed....
task[4] started....
task[4] completed....

  从结果可以看出,交给SingleThreadExecutor管理的任务都是串行执行的。
4、让线程像方法一样返回结果
  线程,是某个任务的一次执行过程,从线程本身来看,它不应该像方法那样具有返回值。但是为了提高程序的灵活性,Java1.5提供了Callable接口,通过Callable接口,可以让线程返回一个值,看下面的例子:
public class CallableDemo
{
    public static void main(String[] args)
    {
        ExecutorService exec = Executors.newCachedThreadPool();
        List<Future<String>> threadRlt = new ArrayList();
        
        for(int i=0; i<5;i++)
        {
            threadRlt.add(exec.submit(new MyTask()));
        }
        
        for (Future<String> f : threadRlt)
        {
            try
            {
                System.out.println(f.get());
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            catch (ExecutionException e)
            {
                e.printStackTrace();
            }
        }
    }
}

class MyTask implements Callable<String>
{
    static int counter = 0;
    private final int id = counter++;


    @Override
    public String call()
    {
        System.out.println("task[" + id + "] started....");
        Thread.currentThread().yield();
        System.out.println("task[" + id + "] completed....");
        
        return "Result of " + id;
    }
}

  输出结果
task[0] started....
task[1] started....
task[0] completed....
task[2] started....
task[1] completed....
task[3] started....
task[3] completed....
task[2] completed....
task[4] started....
Result of 0
Result of 1
Result of 2
Result of 3
task[4] completed....
Result of 4

  从输出结果中,可以看到每个线程的返回值"Result of X"都在main方法中取到并打印到控制台了。

  使用Callable接口时,要注意以下几点:
  • 使用Callable时,要实现的是call()方法,而不是run()方法,并且call()方法是有一个返回值 的;
  • 使用Callable的任务,只能通过Executor.submit()方法来执行,而不能像普通线程那样,通过Thread.start()来启动;
  • Executor.submit()方法返回一个Future对象,通过Future对象的get()方法,可以拿到线程的返回值。如果线程还没有执行结束,那么get()方法会阻塞,一直到线程执行结束。在调用get()方法前,也可以通过isDone方法先判断线程是否已经执行结束。

5、线程的基础知识
  Deamon(后台线程)
  后台线程往往是在运行在后台,给程序提供某些服务的线程,它本身不算是程序的组成部分。所以,当虚拟机中只剩下后台线程时,程序也就自动结束了;但只要还有任何非后台线程在运行着,程序就不会结束。看下面的例子:
public class DaemonThreadDemo
{
    public static void main(String[] args)
    {
        Thread t = new Thread() {
            @Override
            public void run()
            {
                try
                {
                    TimeUnit.SECONDS.sleep(1);
                    System.out.println("Can u see this?");
                }
                catch (InterruptedException e)
                {
                    e.printStackTrace();
                }
                finally
                {
                    System.out.println("Can reach here?");
                }
            }
        };
        
        t.setDaemon(true);
        t.start();
    }
}

  上面的程序不会有任何的输出,甚至连finally里面的内容也没有执行,因为线程t被设置成了后台线程,在它睡眠的1秒种时间里,main(非后台)线程已经结束了,这时虚拟机中只剩下后台进程,这样程序也自动结束了,因而看不到线程t的输出。

  sleep & yield
  sleep()方法让线程睡眠一段时间,时间过后,线程才会去争取cpu时间片。
  Java1.5提供了一个新的TimeUnit枚举,让sleep的可读性更好。
  yield()方法让线程主动让出cpu,让cpu重新调度以决定哪个线程可以使用cpu。


  优先级
  优先级,故名思意,决定了一个线程的重要程度。优先级高的线程并不一定总比优先级低的进程先得到处理,而只是机会高一些。
  虽然java提供了10个优先级级别,但是由于各个平台对进程、线程优先级的定义各不相同,在程序中最好只用三个优先级别MAX_PRIORITY,NORM_PRIORITY,and MIN_PRIORITY。

  join
  如果一个线程访问了另一个线程的join()方法,那当前线程就会处于等待状态,直到另一个线程结束。例如:
class Sleeper extends Thread
{
    public Sleeper()
    {
        start();
    }

    public void run()
    {
        try
        {
            sleep(2000);
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        System.out.println("sleeper has awakened");
    }
}

class Joiner extends Thread
{
    private Sleeper sleeper;

    public Joiner(Sleeper sleeper)
    {
        this.sleeper = sleeper;
        start();
    }

    public void run()
    {
        try
        {
            sleeper.join();
        }
        catch (InterruptedException e)
        {
            System.out.println("Interrupted");
        }
        
        System.out.println("joiner completed");
    }
}

public class Joining
{
    public static void main(String[] args)
    {
        Sleeper sleeper = new Sleeper();
        Joiner joiner = new Joiner(sleeper);
    }
}

  结果输出
sleeper has awakened
joiner completed

  从输出可以看出,joiner在调用了sleeper.join方法后,就会一直等待,直到sleeper执行完了再继续执行。

6、线程的异常处理
  通常情况下,我们会在run()方法里面进行异常处理。但是如果某些时候,需要在run()方法外面处理异常,该怎么办呢?先看下面的例子:
public class ExceptionThread implements Runnable
{
    public void run()
    {
        throw new RuntimeException();
    }

    public static void main(String[] args)
    {
        try
        {
            Thread t = new Thread(new ExceptionThread());
            t.start();
        }
        catch(RuntimeException e)
        {
            System.out.println("caught");
        }
    }
}

  上面的程序并没有像预期那样输出caught,而是直接把异常抛给了控制台。那怎么样才能在run()方法外面处理异常呢?Java1.5提供了一个接口Thread.UncaughtExceptionHandler,只需要实现uncaughtException(Thread t, Throwable e)方法就可以达到我们的目的了,看下面的例子:
public class ExceptionThread implements Runnable
{
    public void run()
    {
        throw new RuntimeException();
    }

    public static void main(String[] args)
    {
        Thread t = new Thread(new ExceptionThread());
        t.setDefaultUncaughtExceptionHandler(new MyHandler());
        t.start();
    }
}

class MyHandler implements Thread.UncaughtExceptionHandler
{
    @Override
    public void uncaughtException(Thread arg0, Throwable arg1)
    {
        System.out.println("caught");
    }
}

  通过实现一个Thread.UncaughtExceptionHandler对象,就可以达到我们的目的了。
7
0
分享到:
评论
4 楼 冬天秋天 2011-11-29  
没有注意到java5的新特新,学习了。
3 楼 fd_zhaoshuo 2011-11-15  
写的挺好的
2 楼 koubai 2011-11-14  
very well
1 楼 Technoboy 2011-11-14  
 

相关推荐

    Java多线程设计模式上传文件

    Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式...

    java 多线程操作数据库

    本文将基于一个具体的Java多线程操作数据库的应用程序,深入探讨其背后的原理、实现细节以及潜在的挑战。 #### 核心知识点: 1. **多线程基础**:多线程是Java编程中的一个重要概念,允许程序同时执行多个任务。在...

    java多线程读取文件

    Java多线程读大文件 java多线程写文件:多线程往队列中写入数据

    Java多线程知识点总结

    Java多线程是Java编程语言中一个非常重要的概念,它允许开发者在一个程序中创建多个执行线程并行运行,以提高程序的执行效率和响应速度。在Java中,线程的生命周期包含五个基本状态,分别是新建状态(New)、就绪...

    java多线程ppt

    java多线程PPT 多线程基本概念 创建线程的方式 线程的挂起与唤醒 多线程问题

    java多线程的讲解和实战

    Java多线程是Java编程中的重要概念,尤其在如今的多核处理器环境下,理解并熟练掌握多线程技术对于提高程序性能和响应速度至关重要。本资料详细讲解了Java多线程的原理,并提供了丰富的实战代码,非常适合Java初学者...

    java多线程经典案例

    Java多线程是Java编程中的重要概念,它允许程序同时执行多个任务,极大地提升了程序的效率和性能。在Java中,实现多线程有两种主要方式:通过实现Runnable接口或者继承Thread类。本案例将深入探讨Java多线程中的关键...

    java多线程分页查询

    通过对上述代码的分析可以看出,该方案充分利用了Java多线程技术的优势,通过预加载前一页的数据,大大提高了后续请求的响应速度。然而,在实际应用中还需要注意以下几点: - **线程池管理**:频繁地创建新线程可能...

    java多线程Demo

    Java多线程是Java编程中的一个重要概念,它允许程序同时执行多个任务,提高了程序的效率和响应速度。在Java中,实现多线程有两种主要方式:继承Thread类和实现Runnable接口。 1. 继承Thread类: 当我们创建一个新...

    java多线程查询数据库

    综上所述,"java多线程查询数据库"是一个涉及多线程技术、线程池管理、并发控制、分页查询等多个方面的复杂问题。通过理解和掌握这些知识点,我们可以有效地提高数据库操作的效率和系统的响应速度。

    java多线程处理数据库数据

    在Java编程中,多线程处理是提升程序性能和效率的重要手段,特别是在处理大量数据库数据时。本主题将深入探讨如何使用Java的并发包(java.util.concurrent)来实现多线程对数据库数据的批量处理,包括增、删、改等...

    深入浅出 Java 多线程.pdf

    在本文中,我们将深入浅出Java多线程编程的世界,探索多线程编程的基本概念、多线程编程的优点、多线程编程的缺点、多线程编程的应用场景、多线程编程的实现方法等内容。 一、多线程编程的基本概念 多线程编程是指...

    java 多线程并发实例

    在Java编程中,多线程并发是提升程序执行效率、充分利用多核处理器资源的重要手段。本文将基于"java 多线程并发实例"这个主题,深入探讨Java中的多线程并发概念及其应用。 首先,我们要了解Java中的线程。线程是...

    汪文君JAVA多线程编程实战(完整不加密)

    《汪文君JAVA多线程编程实战》是一本专注于Java多线程编程的实战教程,由知名讲师汪文君倾力打造。这本书旨在帮助Java开发者深入理解和熟练掌握多线程编程技术,提升软件开发的效率和质量。在Java平台中,多线程是...

    JAVA单线程多线程

    ### JAVA中的单线程与多线程概念解析 #### 单线程的理解 在Java编程环境中,单线程指的是程序执行过程中只有一个线程在运行。这意味着任何时刻只能执行一个任务,上一个任务完成后才会进行下一个任务。单线程模型...

    JAVAJAVA多线程教学演示系统论文

    《JAVA多线程教学演示系统》是一篇深入探讨JAVA多线程编程的论文,它针对教育领域中的教学需求,提供了一种生动、直观的演示方式,帮助学生更好地理解和掌握多线程技术。这篇论文的核心内容可能包括以下几个方面: ...

    多线程启动.java多线程启动.java多线程启动.java

    多线程启动.java多线程启动.java多线程启动.java多线程启动.java

    JAVA多线程练习题答案。

    JAVA多线程练习题答案详解 在本文中,我们将对 JAVA 多线程练习题的答案进行详细的解释和分析。这些题目涵盖了 JAVA 多线程编程的基本概念和技术,包括线程的生命周期、线程同步、线程状态、线程优先级、线程安全等...

    JAVA多线程编程技术PDF

    这份“JAVA多线程编程技术PDF”是学习和掌握这一领域的经典资料,涵盖了多线程的全部知识点。 首先,多线程的核心概念包括线程的创建与启动。在Java中,可以通过实现Runnable接口或继承Thread类来创建线程。创建后...

    Java多线程实现异步调用实例

    总之,Java多线程和异步调用是构建高效、响应迅速的应用程序的关键技术。通过合理利用这些工具和机制,开发者可以编写出能够充分利用多核处理器优势的代码,从而提高软件性能。在实际应用中,理解并熟练掌握这些概念...

Global site tag (gtag.js) - Google Analytics