zoukankan      html  css  js  c++  java
  • Java 多线程初级汇总

    多线程概述

    • 抢占式多任务

      直接中断而不需要事先和被中断程序协商

    • 协作多任务

      被中断程序同意交出控制权之后才能执行中断

    • 多线程和多进程区别?

      本质的区别在于每个进程有它自己的变量的完备集,线程则共享相同的数据

    Thread

    • Thread(Runnable target)

      构造有一个新的线程来调用指定的target的run()方法

    • void start()

      启动这个线程,将引发调用run()方法

    • void run()

      调用关联Runnable的run方法

    • Thread 示例测试代码

    public class ThreadTest extends Thread {
    
        private Thread mThread;
    
        private String mName;
    
        private final int mCount = 4;
    
        public ThreadTest(String name){
            this.mName = name;
            System.out.println("new ThreadTest"+name);
        }
    
        public void run(){
            System.out.println("run " + this.mName);
            try {
                for (int i = 0; i < mCount; i++) {
                    System.out.println(this.mName + "Thread.sleep : " + i);
                    Thread.sleep(50);
                }
            } catch (InterruptedException ie) {
                System.out.println("InterruptedException " + this.mName);
            }
        }
    
        public void start() {
            System.out.println("start " + this.mName);
            if (this.mThread == null) {
                this.mThread = new Thread(this);
                this.mThread.start();
            }
        }
    
        public static void main(String[] args) {
            ThreadTest thread1 = new ThreadTest("test1");
            thread1.start();
            ThreadTest thread2 = new ThreadTest("test2");
            thread2.start();
        }
    }
    
    

    Runnable

    • Runnable封装一个异步运行的任务

    • Runnable示例测试代码

    
    /**
     * Runnable继承类
     */
    public class RunnableTest implements Runnable {
    
        private Thread mThread;
    
        private String mName;
    
        private final int mCount = 4;
    
        public RunnableTest(String name) {
            this.mName = name;
            System.out.println("new RunnableTest" + name);
        }
    
        public void run() {
            System.out.println("run " + this.mName);
            try {
                for (int i = 0; i < mCount; i++) {
                    System.out.println(this.mName + "Thread.sleep : " + i);
                    Thread.sleep(50);
                }
            } catch (InterruptedException ie) {
                System.out.println("InterruptedException " + this.mName);
            }
        }
    
        public void start() {
            System.out.println("start " + this.mName);
            if (this.mThread == null) {
                this.mThread = new Thread(this);
                this.mThread.start();
            }
        }
    
        public static void main(String[] args) {
            RunnableTest run1 = new RunnableTest("test1");
            run1.start();
            RunnableTest run2 = new RunnableTest("test2");
            run2.start();
        }
    
    }
    
    
    

    Callable和Future

    • Callable接口是一个参数化的类型,有一个方法call

    • Future保存异步计算的结果。当使用Future对象,启动有一个计算,把计算结果给某线程,Future对象在所有者结果计算好之后就可以得到它

    • call()

      运行一个将产生结果的任务

    • 代码示例

    import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.FutureTask;
    
    public class CallableTest implements Callable<Integer> {
    
        public Integer call() throws Exception {
            int i = 0;
            for (; i < 100; i++) {
                System.out.println(Thread.currentThread().getName() + " " + i);
            }
            return i;
        }
    
        public static void main(String[] args) {
            CallableTest test = new CallableTest();
    
            FutureTask<Integer> task = new FutureTask<Integer>(test);
    
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName() + " 的循环变量i的值" + i);
                if (i == 20) {
                    new Thread(task, "有返回值的线程").start();
                }
            }
    
            try {
                System.out.println("子线程的返回值:" + task.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
    
        }
    }
    
    

    线程池

    如果你的程序创建了大量生存期很短的线程,就应该使用线程池一个线程池包含大量准备运行的空闲线程。将一个Runnable对象给线程池,线程池中的一个线程就会调用run方法。
    
    • newCachedThreadPool 构建,如果有空闲线程可用,立即让它执行任务,否则创建一个新线程
    • newFixedThreadPool 创建一个大小固定的线程池。如果提交的任务数大于空闲线程数,那么得不到服务的任务将被置于队列中
    • newSingleTreadExecutor是一个退化了大小为1的线程池
  • 相关阅读:
    FineUI开源版(ASP.Net)初学手册-部分JS整理
    ASP.NET-FineUI开发实践-15
    ASP.NET-FineUI开发实践-14
    FineUI开源版(ASP.Net)开发实践-目录
    ASP.NET-FineUI开发实践-13(二)
    ASP.NET-FineUI开发实践-13(一)
    在VS.NET中根据条件设置不同的MainForm
    VB.NET在基类中定义共享事件(类似于C#中的静态事件)
    也谈解决Combobox绑定数据后取值出现System.Data.DataRowView的问题
    在SQL Server 2014下面使用的SQL2000的Northwind和Pubs示例数据库
  • 原文地址:https://www.cnblogs.com/bmbh/p/9075960.html
Copyright © 2011-2022 走看看