精华内容
下载资源
问答
  • 由于FPC特容易损伤,因此生产和包装时必须格外小心,现将几种常用的包装方式稍作总结,供各位参考。
  • 多线程的几种实现方式

    万次阅读 多人点赞 2019-02-25 15:33:38
    java多线程的几种实现方式: 1.继承Thread类,重写run方法 2.实现Runnable接口,重写run方法,实现Runnable接口的实现类的实例对象作为Thread构造函数的target 3.通过Callable和FutureTask创建线程 4.通过线程池...

    上篇文章总结了下关于线程池很干,很干的干货,这次想着顺便连其他实现多线程的三种方式也汇总下吧!

    java多线程的几种实现方式:

    1.继承Thread类,重写run方法
    2.实现Runnable接口,重写run方法,实现Runnable接口的实现类的实例对象作为Thread构造函数的target
    3.通过Callable和FutureTask创建线程
    4.通过线程池创建线程  (上一篇已经讲过了)

    前面两种可以归结为一类:无返回值,原因很简单,通过重写run方法,run方式的返回值是void,所以没有办法返回结果 
    后面两种可以归结成一类:有返回值,通过Callable接口,就要实现call方法,这个方法的返回值是Object,所以返回的结果可以放在Object对象中

    方式1:继承Thread类的线程实现方式如下:

    public class ThreadDemo01 extends Thread{
        public ThreadDemo01(){
            //编写子类的构造方法,可缺省
        }
        public void run(){
            //编写自己的线程代码
            System.out.println(Thread.currentThread().getName());
        }
        public static void main(String[] args){ 
            ThreadDemo01 threadDemo01 = new ThreadDemo01(); 
            threadDemo01.setName("我是自定义的线程1");
            threadDemo01.start();       
            System.out.println(Thread.currentThread().toString());  
        }
    }


    程序结果: 
    Thread[main,5,main] 
    我是自定义的线程1

    线程实现方式2:通过实现Runnable接口,实现run方法,接口的实现类的实例作为Thread的target作为参数传入带参的Thread构造函数,通过调用start()方法启动线程

    public class ThreadDemo02 {
    
        public static void main(String[] args){ 
            System.out.println(Thread.currentThread().getName());
            Thread t1 = new Thread(new MyThread());
            t1.start(); 
        }
    }
    
    class MyThread implements Runnable{
        @Override
        public void run() {
            // TODO Auto-generated method stub
            System.out.println(Thread.currentThread().getName()+"-->我是通过实现接口的线程实现方式!");
        }   
    }


    程序运行结果: 
    main 
    Thread-0–>我是通过实现接口的线程实现方式!

    线程实现方式3:通过Callable和FutureTask创建线程 
    a:创建Callable接口的实现类 ,并实现Call方法 
    b:创建Callable实现类的实现,使用FutureTask类包装Callable对象,该FutureTask对象封装了Callable对象的Call方法的返回值 
    c:使用FutureTask对象作为Thread对象的target创建并启动线程 
    d:调用FutureTask对象的get()来获取子线程执行结束的返回值

    public class ThreadDemo03 {
    
        /**
         * @param args
         */
        public static void main(String[] args) {
            // TODO Auto-generated method stub
    
            Callable<Object> oneCallable = new Tickets<Object>();
            FutureTask<Object> oneTask = new FutureTask<Object>(oneCallable);
    
            Thread t = new Thread(oneTask);
    
            System.out.println(Thread.currentThread().getName());
    
            t.start();
    
        }
    
    }
    
    class Tickets<Object> implements Callable<Object>{
    
        //重写call方法
        @Override
        public Object call() throws Exception {
            // TODO Auto-generated method stub
            System.out.println(Thread.currentThread().getName()+"-->我是通过实现Callable接口通过FutureTask包装器来实现的线程");
            return null;
        }   
    }


    程序运行结果: 
    main 
    Thread-0–>我是通过实现Callable接口通过FutureTask包装器来实现的线程

    线程实现方式4:通过线程池创建线程

    public class ThreadDemo05{
    
        private static int POOL_NUM = 10;     //线程池数量
    
        /**
         * @param args
         * @throws InterruptedException 
         */
        public static void main(String[] args) throws InterruptedException {
            // TODO Auto-generated method stub
            ExecutorService executorService = Executors.newFixedThreadPool(5);  
            for(int i = 0; i<POOL_NUM; i++)  
            {  
                RunnableThread thread = new RunnableThread();
    
                //Thread.sleep(1000);
                executorService.execute(thread);  
            }
            //关闭线程池
            executorService.shutdown(); 
        }   
    
    }
    
    class RunnableThread implements Runnable  
    {     
        @Override
        public void run()  
        {  
            System.out.println("通过线程池方式创建的线程:" + Thread.currentThread().getName() + " ");  
    
        }  
    }  


    程序运行结果: 
    通过线程池方式创建的线程:pool-1-thread-3 
    通过线程池方式创建的线程:pool-1-thread-4 
    通过线程池方式创建的线程:pool-1-thread-1 
    通过线程池方式创建的线程:pool-1-thread-5 
    通过线程池方式创建的线程:pool-1-thread-2 
    通过线程池方式创建的线程:pool-1-thread-5 
    通过线程池方式创建的线程:pool-1-thread-1 
    通过线程池方式创建的线程:pool-1-thread-4 
    通过线程池方式创建的线程:pool-1-thread-3 
    通过线程池方式创建的线程:pool-1-thread-2

    ExecutorService、Callable都是属于Executor框架。返回结果的线程是在JDK1.5中引入的新特征,还有Future接口也是属于这个框架,有了这种特征得到返回值就很方便了。 
    通过分析可以知道,他同样也是实现了Callable接口,实现了Call方法,所以有返回值。这也就是正好符合了前面所说的两种分类

    执行Callable任务后,可以获取一个Future的对象,在该对象上调用get就可以获取到Callable任务返回的Object了。get方法是阻塞的,即:线程无返回结果,get方法会一直等待。

    再介绍Executors类:提供了一系列工厂方法用于创建线程池,返回的线程池都实现了ExecutorService接口。

    public static ExecutorService newFixedThreadPool(int nThreads) 
    创建固定数目线程的线程池。
    public static ExecutorService newCachedThreadPool() 
    创建一个可缓存的线程池,调用execute 将重用以前构造的线程(如果线程可用)。如果现有线程没有可用的,则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。
    public static ExecutorService newSingleThreadExecutor() 
    创建一个单线程化的Executor。
    public static ScheduledExecutorService newScheduledThreadPool(int 
    corePoolSize) 
    创建一个支持定时及周期性的任务执行的线程池,多数情况下可用来替代Timer类。
    ExecutoreService提供了submit()方法,传递一个Callable,或Runnable,返回Future。如果Executor后台线程池还没有完成Callable的计算,这调用返回Future对象的get()方法,会阻塞直到计算完成。

    总结:

    引用阿里的关于  线程的建议:

    展开全文
  • 对于这两,也分别启动线程的方式: 1)继承Thread类,implements Runnable接口 2)实现Callable接口通过FutureTask包装器来创建Thread线程、使用ExecutorService、Callable、Future实现返回结果的线程 ...

    1、启动线程方式:

    要启动的可以分为两类:返回结果和不返回结果。对于这两种,也分别有两种启动线程的方式:

    1)继承Thread类,implements Runnable接口

    2)实现Callable接口通过FutureTask包装器来创建Thread线程、使用ExecutorService、Callable、Future实现有返回结果的线程

    具体使用请参考:https://www.cnblogs.com/felixzh/p/6036074.html但是这里对FutureTask结果返回没有说明,参考下篇

    https://wenku.baidu.com/view/89925c32fad6195f312ba697.html

    2、线程池的种类

    四种。

    查了网上的一些资料,上面都是先讲线程池存在的必要性:针对一些需要处理的短小而数量巨多的线程。比如在服务器中客户端浏览器的请求就有短小数量多的特点。

    如果我们单纯地执行来一个请求回复一个,来回切换线程的代价太大。比如你要二十种不同的水果,他们分别放在相隔一米的管道里,并且每种水果发来的请求不一致,比如有的想要去皮,有的想要切盘,这时线程可以看作是“去皮”“切盘”前的准备工作,比如冲洗一下或者准备水果刀之类的。把线程准备好之后就可以进行最后的处理。

    这时候,如果苹果说他想去皮,你要准备水果刀,再传过去给老大处理,二十米开外的菠萝说他想切块,你得准备螺丝刀,再给老大处理,是不是很麻烦,来回跑下来累得不行,还要准备不同的工具,效率太低。这时候就有了线程池的说法。线程池,每一个线程为一个要求服务,比如去皮,就创建去皮的线程,去核,就创建去核的线程(一般来说,某种水果对应的要求是一致的)。这里线程就是为去核,去皮做准备工作。这时候,就不用重复准备工作了。

    四种线程池:https://www.cnblogs.com/aaron911/p/6213808.html

     

     

     

    展开全文
  • python多线程有几种实现方法

    千次阅读 2015-05-26 11:26:19
    python多线程有几种实现方法,都是什么?   目前python 提供了几种多线程实现方式 thread,threading,multithreading ,其中thread模块比较底层,而threading模块是对thread做了一些包装,可以更加方便的被使用...

    python多线程有几种实现方法,都是什么?

            目前python 提供了几种多线程实现方式 thread,threading,multithreading ,其中thread模块比较底层,而threading模块是对thread做了一些包装,可以更加方便的被使用。2.7版本之前python对线程的支持还不够完善,不能利用多核CPU,但是2.7版本的python中已经考虑改进这点,出现了multithreading  模块。threading模块里面主要是对一些线程的操作对象化,创建Thread的class。

            一般来说,使用线程有两种模式:

            A 创建线程要执行的函数,把这个函数传递进Thread对象里,让它来执行;
            B 继承Thread类,创建一个新的class,将要执行的代码 写到run函数里面。


    第一种 创建函数并且传入Thread 对象

    
        import threading,time
        from time import sleep, ctime
        def now() :
            return str( time.strftime( '%Y-%m-%d %H:%M:%S' , time.localtime() ) )
    
        def test(nloop, nsec):
            print 'start loop', nloop, 'at:', now()
            sleep(nsec)
            print 'loop', nloop, 'done at:', now()
    
        def main():
            print 'starting at:',now()
            threadpool=[]
    
            for i in xrange(10):
                th = threading.Thread(target= test,args= (i,2))
                threadpool.append(th)
    
            for th in threadpool:
                th.start()
    
            for th in threadpool :
                threading.Thread.join( th )
    
            print 'all Done at:', now()
    
        if __name__ == '__main__':
                main()
    
    


    第二种是创建一个新的class,将要执行的代码 写到run函数里面。

    
        import threading ,time
        from time import sleep, ctime
        def now() :
            return str( time.strftime( '%Y-%m-%d %H:%M:%S' , time.localtime() ) )
    
        class myThread (threading.Thread) :
              """docstring for myThread"""
              def __init__(self, nloop, nsec) :
                  super(myThread, self).__init__()
                  self.nloop = nloop
                  self.nsec = nsec
    
              def run(self):
                  print 'start loop', self.nloop, 'at:', ctime()
                  sleep(self.nsec)
                  print 'loop', self.nloop, 'done at:', ctime()
        def main():
             thpool=[]
             print 'starting at:',now()
            
             for i in xrange(10):
                 thpool.append(myThread(i,2))
                 
             for th in thpool:
                 th.start()
           
             for th in thpool:
                 th.join()
            
             print 'all Done at:', now()
    
        if __name__ == '__main__':
                main()
    
    


    展开全文
  • 1.多线程4实现方法 继承Thread类,重写run方法 实现Runnable接口,重写run方法,实现Runnable接口的实现类的实例对象作为Thread构造函数的target 通过Callable和FutureTask创建线程 通过线程池创建线程 同步...

    1.多线程有4种实现方法

    • 继承Thread类,重写run方法
    • 实现Runnable接口,重写run方法,实现Runnable接口的实现类的实例对象作为Thread构造函数的target
    • 通过Callable和FutureTask创建线程
    • 通过线程池创建线程

    同步的实现方面有两种,分别是synchronized,wait与notify

    2.wait():使一个线程处于等待状态,并且释放所持有的对象的lock。

     sleep():使一个正在运行的线程处于睡眠状态,是一个静态方法, * 调用此方法要捕捉InterruptedException异常 * 。

     notify():唤醒一个处于等待状态的线程,注意的是在调用此方法的时候,并不能确切的唤醒某一个等待状态的线程 ,而是由JVM确定唤醒哪个线程,而且不是按优先级  。 

       notifyAll():唤醒所有处入等待状态的线程,注意并不是给所有唤醒线程一个对象的锁,而是让它们竞争。
    3.

    方式1:继承Thread类的线程实现方式如下:

    public class ThreadDemo01 extends Thread{
        public ThreadDemo01(){
            //编写子类的构造方法,可缺省
        }
        public void run(){
            //编写自己的线程代码
            System.out.println(Thread.currentThread().getName());
        }
        public static void main(String[] args){ 
            ThreadDemo01 threadDemo01 = new ThreadDemo01(); 
            threadDemo01.setName("我是自定义的线程1");
            threadDemo01.start();       
            System.out.println(Thread.currentThread().toString());  
        }
    }


    程序结果: 

    Thread[main,5,main] 
    我是自定义的线程1

    线程实现方式2:通过实现Runnable接口,实现run方法,接口的实现类的实例作为Thread的target作为参数传入带参的Thread构造函数,通过调用start()方法启动线程

    public class ThreadDemo02 {
    
        public static void main(String[] args){ 
            System.out.println(Thread.currentThread().getName());
            Thread t1 = new Thread(new MyThread());
            t1.start(); 
        }
    }
    
    class MyThread implements Runnable{
        @Override
        public void run() {
            // TODO Auto-generated method stub
            System.out.println(Thread.currentThread().getName()+"-->我是通过实现接口的线程实现方式!");
        }   
    }

    程序运行结果: 

    main 
    Thread-0–>我是通过实现接口的线程实现方式!

    线程实现方式3:通过Callable和FutureTask创建线程 
    a:创建Callable接口的实现类 ,并实现Call方法 
    b:创建Callable实现类的实现,使用FutureTask类包装Callable对象,该FutureTask对象封装了Callable对象的Call方法的返回值 
    c:使用FutureTask对象作为Thread对象的target创建并启动线程 
    d:调用FutureTask对象的get()来获取子线程执行结束的返回值

    public class ThreadDemo03 {
    
        /**
         * @param args
         */
        public static void main(String[] args) {
            // TODO Auto-generated method stub
    
            Callable<Object> oneCallable = new Tickets<Object>();
            FutureTask<Object> oneTask = new FutureTask<Object>(oneCallable);
    
            Thread t = new Thread(oneTask);
    
            System.out.println(Thread.currentThread().getName());
    
            t.start();
    
        }
    
    }
    
    class Tickets<Object> implements Callable<Object>{
    
        //重写call方法
        @Override
        public Object call() throws Exception {
            // TODO Auto-generated method stub
            System.out.println(Thread.currentThread().getName()+"-->我是通过实现Callable接口通过FutureTask包装器来实现的线程");
            return null;
        }   
    }

    程序运行结果:

    main 
    Thread-0–>我是通过实现Callable接口通过FutureTask包装器来实现的线程

    线程实现方式4:通过线程池创建线程

    public class ThreadDemo05{
    
        private static int POOL_NUM = 10;     //线程池数量
    
        /**
         * @param args
         * @throws InterruptedException 
         */
        public static void main(String[] args) throws InterruptedException {
            // TODO Auto-generated method stub
            ExecutorService executorService = Executors.newFixedThreadPool(5);  
            for(int i = 0; i<POOL_NUM; i++)  
            {  
                RunnableThread thread = new RunnableThread();
    
                //Thread.sleep(1000);
                executorService.execute(thread);  
            }
            //关闭线程池
            executorService.shutdown(); 
        }   
    
    }
    
    class RunnableThread implements Runnable  
    {     
        @Override
        public void run()  
        {  
            System.out.println("通过线程池方式创建的线程:" + Thread.currentThread().getName() + " ");  
    
        }  
    }  


    原文:https://blog.csdn.net/u011480603/article/details/75332435/ 
    版权声明:本文为博主原创文章,转载请附上博文链接!

    展开全文
  • Java 中有几种类型的流

    千次阅读 2019-03-13 21:44:51
    Java 中有几种类型的流 按照流的方向:输入流(inputStream)和输出流(outputStream)。 按照实现功能分:节点流(可以从或向一个特定的地方(节点)读写数据 如 FileReader。 处理流(是对一个已存在的流的连接...
  • 多线程的实现方式有如下三 1)继承Thread类创建线程 重写run方法 2)实现Runnable接口创建线程 3)使用Callable和Future创建线程 重写call方法 通过继承Thread类来创建并启动多线程的一般步骤如下 1. 定义Thread类...
  • 它猴子修补了几个类以添加新功能,并添加了一个新的“ SmartsheetUtilities”子类(可从smartsheet_client.Util访问),该子类包含执行更复杂但常见操作的几种方法。 做出决定是对智能表sdk进行猴子补丁,而不是对...
  • 实现Runnable和实现Callable接口的方式基本相同,不过是后者执行call()方法有返回值。 1、如果需要访问当前线程,必须调用Thread.currentThread()方法。 2、继承Thread类的线程类不能再继承其他父类(...
  • 创建线程有几种不同的方式

    千次阅读 2017-04-20 10:45:26
    ②实现Runnable接口,并重写里面的run方法。 ③使用Executor框架创建线程池。Executor框架是juc里提供的线程池的实现。 调用线程的start():启动此线程;调用相应的run()方法 继承于Thread类的线程类,可以直接...
  • 创建对象的方式 方式 是否调用了构造函数 使用new关键字 是 使用Class类的newInstance方法 是 使用Constructor类的newInstance方法 是 使用clone方法 否 使用反序列化 否 1.使用new...
  • 反射实现的几种方法

    千次阅读 2015-10-18 11:14:58
    1 类名.class 2 Class.forName("类全名") 3 对象名.getClass() 4 基本数据类型的包装类 Integer.TYPE  ...//反射的几种方法 public static void main(String[] args) { System.out.println(RefTest.class);//類名
  • java中创建对象的几种方式

    千次阅读 2017-06-26 15:58:42
    创建对象的几种方式
  • JAVA多线程几种实现方式

    千次阅读 2017-11-10 10:20:12
    返回值: (1) 继承Thread类  1)定义Thread类的子类,并重写Thread类的run()方法。 2)创建Thread子类的实例,及创建了线程对象。 3)调用线程对象的start()方法来启动该线程。 Thread类常用方法 Thread....
  • SpringMVC 的几种传参的方式

    千次阅读 2016-07-13 19:08:18
    下面总结一下项目中使用到的几种传递参数的方式。 1.通过form表单的方式来传递参数。 这种方式重要试用于多个参数需要传递到后台处理。并且这些字段在同一个实体类中。这样就可以通过表单序列化的方式。将整个...
  • 多线程的几种实现方法

    千次阅读 2019-05-03 15:48:32
    Java多线程实现方式主要:继承Thread类、实现Runnable接口、实现Callable接口通过FutureTask包装器来创建Thread线程、使用ExecutorService、Callable、Future实现返回结果的多线程。 其中前两种方式线程执行...
  • java上传文件常见几种方式

    万次阅读 2019-08-06 06:39:19
     表单提交中当提交数据类型是multipare/form-data类型的时候,如果我们用servlet去做处理的话,该http请求就会被servlet容器,包装成httpservletRequest对象  ,在由相应的servlet进行处理。 package ...
  • 种方式: ①继承Thread类(真正意义上的线程类),是Runnable接口的实现。 ②实现Runnable接口,并重写里面的run方法。 ③使用Executor框架创建线程池。Executor框架是juc里提供的线程池的实现。调用线程的start...
  • //因为这里演示get方式请求,所以直接调用doGet()方法 doGet(request, response); } } 通过一个基类servlet解决中文乱码 1.先写一个BaseServlet类 import java.io.IOException; import java.io....
  • c++调用webservice接口的几种方法以及实例

    万次阅读 多人点赞 2018-10-19 15:38:32
    c++调用webservice接口的几种方法以及实例 前言 最近在做这方面的工作,过程中遇到一些问题,故在此整理并分享一下,让后来者少走一些弯路.废话不多说,直接上干货. 准备工具:sproxy.exe/wsdl.exe;gsoap.均存在我的网盘...
  • 在python下安装app一般有几种方法

    千次阅读 2014-10-27 02:15:52
    Django做为python下最大的web框架,在国外非常流行。 也产生了很多的第三方app,Django的app就是一个可...另外在github上面也非常多的可复用app,充分利用这些第三方app可以大大提高您的效率。 我比较常用的app
  • List初始化赋值的几种方式

    千次阅读 2021-02-05 10:24:06
    所以百度了一下,了解了list的其他几种初始化方式,现记录一下。 1.构造 List 后使用 List.add 初始化 List<String> stringList = new LinkedList<>(); stringList.add("a"); stringList.add("b"); ...
  • 1,继承Thread类,重写run方法; 2,实现Runnable接口,重写run方法,但是比继承Thread类好用,实现接口还可以继承类,避免了单继承带来的局限性; 3,使用Executor框架创建线程池。Executor框架是juc里提供的线程池...
  • Solr 删除数据的几种方式

    千次阅读 2016-06-07 16:12:15
    时候需要删除 Solr 中的数据(特别是不重做...删除 solr 中的数据有几种方式: 1、先来看 curl 方式: curl http://localhost:8080/solr/update --data-binary "title:abc" -H 'Content-type:tex
  • 创建线程的几种方式

    千次阅读 2018-08-27 15:48:35
    一般种方法,Thread,Runnable,Callable,使用Executor框架来创建线程池。 Runnable和Callable的区别是, (1)Callable规定的方法是call(),Runnable规定的方法是run(). (2)Callable的任务执行后可返回值,而...
  • 常见的接口调用方式有(设计接口的时候要考虑选用哪接口) 1、http接口:http是一网络传输协议,基于TCP。(等价于:http+json) 现在浏览器客户端与服务器端通信基本都是采用http协议。 SpringCloud框架,...
  • Solr 删除数据的几种方式

    万次阅读 2010-10-20 16:22:00
    Solr 删除数据的几种方式

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 223,671
精华内容 89,468
关键字:

包装方式有几种