nlhappy/STI-QA huggingface dataset:
Callable与Runnable  java.lang.Runnable吧,它是一个接口,在它里面只声明了一个run()方法:  public interface Runnable { public abstract void run(); }  由于run()方法返回值为void类型,所以在执行完任务之后无法返回任何结果。
Callable位于java.util.concurrent包下,它也是一个接口,在它里面也只声明了一个方法,只不过这个方法叫做call():  public interface Callable<V> { /** * Computes a result, or throws an exception if unable to do so. * * @return computed result * @throws Exception if unable to compute a result */ V call() throws Exception; }  可以看到,这是一个泛型接口,call()函数返回的类型就是传递进来的V类型。  那么怎么使用Callable呢?
一般情况下是配合ExecutorService来使用的,在ExecutorService接口中声明了若干个submit方法的重载版本:  Future submit(Callable task);  Future submit(Runnable task, T result);  Future<?> submit(Runnable task);  第一个submit方法里面的参数类型就是Callable。  暂时只需要知道Callable一般是和ExecutorService配合来使用的,具体的使用方法讲在后面讲述。  一般情况下我们使用第一个submit方法和第三个submit方法,第二个submit方法很少使用。  Future  Future就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果。必要时可以通过get方法获取执行结果,该方法会阻塞直到任务返回结果。
Future类位于java.util.concurrent包下,它是一个接口:  public interface Future<V> { boolean cancel(boolean mayInterruptIfRunning); boolean isCancelled(); boolean isDone(); V get() throws InterruptedException, ExecutionException; V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException; }  在Future接口中声明了5个方法,下面依次解释每个方法的作用:  cancel方法用来取消任务,如果取消任务成功则返回true,如果取消任务失败则返回false。参数mayInterruptIfRunning表示是否允许取消正在执行却没有执行完毕的任务,如果设置true,则表示可以取消正在执行过程中的任务。
Java中创建线程的3种方式及区别  进程:进行中的程序,执行中的程序。在使用电脑时,我们通常会打开多个应用程序,如浏览器,网易云音乐等,而这些打开着的应用程序就称之为进程。  线程:一个进程可以同时执行多个任务,如一个视频播放器可以同时缓存多集电视剧(VIP用户),一个浏览器可以同时下载多张图片等,通常我们将这一个个任务称为线程。  Java中Thread类是线程操作的核心类。而通过下图我们可以发现Thread类其实是Runnable接口的实现类,即Thread类实现了Runnable接口的抽象方法->run()方法。  Runnable接口:  Thread类是Runnable接口的实现类:  Thread类覆写了Runnable接口的方法:  那么我们自然而然可以想到第一种创建线程的方法就是直接继承Thread类,然后通过覆写父类,即Thread类的run方法方法来实现自己的功能。  但是直接调用run方法是否可行呢?
而我们知道多线程是异步执行,并发执行,所以我们不能直接通过run方法启动线程。
那么start0()又是什么方法呢?  privatenativevoidstart0();  start0()是一个被native 修饰的本地方法,需要依赖平台实现。而Thread类中有一个静态代码块,此代码块中存放了一个方法->registerNatives()方法,该方法主要就是注册一些本地方法供Thread类使用。其中就包括start0()方法,而start0()又会调用JVM_StartThread方法,该方法则会调用run方法。
public  classThreadimplementsRunnable{  /* Make sure registerNatives is the first thing <clinit> does. */  privatestaticnativevoidregisterNatives();  static{  registerNatives();  }  所以,我们可以得出的结论是,start()方法中虽然没有run方法,但是它会间接调用run方法:start() -> start0() -> JVM_StartThread -> run()。所以,我们可以通过覆写run方法来实现我们想要的功能,并调用start方法启动线程去执行。  第一种创建线程的方式:直接继承Thread类  步骤:  创建一个子类(该子类直接继承Thread类),该子类通过覆写Thread类的run()方法来实现自己的逻辑操作。
Java中创建线程的3种方式以及区别  Java使用Thread类代表线程,所有的线程对象都必须是Thread类或其子类的实例。Java可以用三种方式来创建线程,如下所示:  1)继承Thread类创建线程  2)实现Runnable接口创建线程  3)使用Callable和Future创建线程  下面让我们分别来看看这三种创建线程的方法。  继承Thread类创建线程  通过继承Thread类来创建并启动多线程的一般步骤如下:  定义Thread类的子类,并重写该类的run()方法,该方法的方法体就是线程需要完成的任务,run()方法也称为线程执行体。  创建Thread子类的实例,也就是创建了线程对象。  启动线程,即调用线程的start()方法。
public class MyThread extends Thread {  @Override  public void run() {  //线程的执行体  }  }  public class Test {  public static void main(String[] args) {  new MyThread().start();  }  }  实现Runnable接口创建线程  通过实现Runnable接口创建并启动线程一般步骤如下:  定义Runnable接口的实现类,一样要重写run()方法,这个run()方法和Thread中的run()方法一样是线程的执行体。  创建Runnable实现类的实例,并用这个实例作为Thread的target来创建Thread对象,这个Thread对象才是真正的线程对象。(注: 启动线程是start()方法,run()并不能启动一个新的线程)  第三步依然是通过调用线程对象的start()方法来启动线程。
public class MyThread2 implements Runnable {  @Override  public void run() {  //线程的执行体  }  }  public class Test {  public static void main(String[] args) {  new Thread(new MyThread2()).start();  }  }  使用Callable和Future创建线程  和Runnable接口不一样,Callable接口提供了一个call()方法作为线程执行体,call()方法比run()方法功能要强大。  核心:  Java5提供了Future接口来代表Callable接口里call()方法的返回值,并且为Future接口提供了一个实现类FutureTask,这个实现类既实现了Future接口,还实现了Runnable接口,因此可以作为Thread类的target。在Future接口里定义了几个公共方法来控制它关联的Callable任务。
call()方法可以有返回值  call()方法可以声明抛出异常  boolean cancel(boolean mayInterruptIfRunning):视图取消该Future里面关联的Callable任务。  V get():返回Callable里call()方法的返回值,调用这个方法会导致程序阻塞,必须等到子线程结束后才会得到返回值  V get(long timeout,TimeUnit unit):返回Callable里call()方法的返回值,最多阻塞timeout时间,经过指定时间没有返回抛出TimeoutException。  boolean isDone():若Callable任务完成,返回True。  boolean isCancelled():如果在Callable任务正常完成前被取消,返回True。
介绍了相关的概念之后,创建并启动有返回值的线程的步骤如下:  1】创建Callable接口的实现类,并实现call()方法,然后创建该实现类的实例(从java8开始可以直接使用Lambda表达式创建Callable对象)。  2】使用FutureTask类来包装Callable对象,该FutureTask对象封装了Callable对象的call()方法的返回值。(FutureTask是一个包装器,它通过接受Callable对象来创建,它同时实现了Future和Runnable接口。
Java创建线程的三种方式及对比 巅峰小词典 发布于 2020-06-14  对于你喜欢的事想去做的事,你必须付出百分之一千的努力,你知道这一路可能会有很多困难,会有坚持不下去想要放弃的时候,也有时候,你不一定会得到你想要的结果,但你一定要相信,就算再贫瘠的土地你日日灌溉,总有那么一天会长出花草来的,所以你一定要坚持。  一、Java中创建线程主要有三种方式:  1、继承Thread类创建线程类  定义Thread类的子类,并重写该类的run方法,该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。  创建Thread子类的实例,即创建了线程对象。  调用线程对象的start()方法来启动该线程。
2、通过Runnable接口创建线程类  定义Runnable接口的实现类,并重写该接口的run()方法,该run()方法的方法体同样是该线程的线程执行体。  创建Runnable实现类的实例,并以此实例作为Thread的target来创建Thread对象,该Thread对象才是真正的线程对象。  调用线程对象的start()方法来启动该线程。
3、通过Callable和Future创建线程  (1)创建Callable接口的实现类,并实现call()方法,该call()方法将作为线程执行体,并且有返回值。  public interface Callable { V call() throws Exception; }  (2)创建Callable实现类的实例,使用FutureTask类来包装Callable对象,该FutureTask对象封装了该Callable对象的call()方法的返回值。(FutureTask是一个包装器,它通过接受Callable来创建,它同时实现了Future和Runnable接口。)  (3)使用FutureTask对象作为Thread对象的target创建并启动新线程。  (4)调用FutureTask对象的get()方法来获得子线程执行结束后的返回值。
在这种方式下,多个线程可以共享同一个target对象,所以非常适合多个相同线程来处理同一份资源的情况,从而可以将CPU、代码和数据分开,形成清晰的模型,较好地体现了面向对象的思想。  劣势是:  编程稍微复杂,如果要访问当前线程,则必须使用Thread.currentThread()方法。  2、使用继承Thread类的方式创建多线程时  优势是:  编写简单,如果需要访问当前线程,则无需使用Thread.currentThread()方法,直接使用this即可获得当前线程。  劣势是:  线程类已经继承了Thread类,所以不能再继承其他父类。  3、Runnable和Callable的区别  (1) Callable规定(重写)的方法是call(),Runnable规定(重写)的方法是run()。  (2) Callable的任务执行后可返回值,而Runnable的任务是不能返回值的。  (3) call方法可以抛出异常,run方法不可以。  (4) 运行Callable任务可以拿到一个Future对象,表示异步计算的结果。
Java中创建线程的三种方式以及区别  在java中如果要创建线程的话,一般有3种方法:  继承Thread类;  实现Runnable接口;  使用Callable和Future创建线程。  继承Thread类的话,必须重写run方法,在run方法中定义需要执行的任务。  1classMyThreadextendsThread{2privatestaticintnum = 0;34publicMyThread(){5num++;6}78@Override9publicvoidrun() {10System.out.println("主动创建的第"+num+"个线程");11}12}  创建好了自己的线程类之后,就可以创建线程对象了,然后通过start()方法去启动线程。注意,不是调用run()方法启动线程,run方法中只是定义需要执行的任务,如果调用run方法,即相当于在主线程中执行run方法,跟普通的方法调用没有任何区别,此时并不会创建一个新的线程来执行定义的任务。
1publicclassTest {2publicstaticvoidmain(String[] args) {3MyThread thread =newMyThread();4thread.start();5}6}789classMyThreadextendsThread{10privatestaticintnum = 0;1112publicMyThread(){13num++;14}1516@Override17publicvoidrun() {18System.out.println("主动创建的第"+num+"个线程");19}20}  在上面代码中,通过调用start()方法,就会创建一个新的线程了。
在Java中创建线程除了继承Thread类之外,还可以通过实现Runnable接口来实现类似的功能。实现Runnable接口必须重写其run方法。
下面是一个例子:  1publicclassTest {2publicstaticvoidmain(String[] args) {3System.out.println("主线程ID:"+Thread.currentThread().getId());4MyRunnable runnable =newMyRunnable();5Thread thread =newThread(runnable);6thread.start();7}8}91011classMyRunnableimplementsRunnable{1213publicMyRunnable() {1415}1617@Override18publicvoidrun() {19System.out.println("子线程ID:"+Thread.currentThread().getId());20}21}  Runnable的中文意思是“任务”,顾名思义,通过实现Runnable接口,我们定义了一个子任务,然后将子任务交由Thread去执行。
注意,这种方式必须将Runnable作为Thread类的参数,然后通过Thread的start方法来创建一个新线程来执行该子任务。如果调用Runnable的run方法的话,是不会创建新线程的,这根普通的方法调用没有任何区别。  事实上,查看Thread类的实现源代码会发现Thread类是实现了Runnable接口的。  在Java中,这2种方式都可以用来创建线程去执行子任务,具体选择哪一种方式要看自己的需求。直接继承Thread类的话,可能比实现Runnable接口看起来更加简洁,但是由于Java只允许单继承,所以如果自定义类需要继承其他类,则只能选择实现Runnable接口。  和Runnable接口不一样,Callable接口提供了一个call()方法作为线程执行体,call()方法比run()方法功能要强大。  创建并启动有返回值的线程的步骤如下:  创建Callable接口的实现类,并实现call()方法,然后创建该实现类的实例(从java8开始可以直接使用Lambda表达式创建Callable对象)。
创建多线程的三种方式和区别  方式一:继承Thread类  1.自定义一个类继承Thread类;  2.重写Thread类中的run方法(自定义线程的任务代码就放在run方法里);  3.创建Thread子类的对象,并且调用start方法开启线程,(run方法不能直接调用)  示例:  class Demo extends Thread{  public void run(){ //重写run方法  for(int i=0;i<100;i++){  System.out.println("自定义线程"+i)  }  }  public static void main(String[] args){  Demo d = new Demo();  d.start(); //调用start方法开启线程  for(int i=0;i<100;i++){  System.out.println("main线程"+i)  }  }  方式二:实现Runnable接口  Thread类中有构造方法,可以传递Runnable实例。
示例:  class Demo1 implements Runnable{  public void run(){ //重写run方法  for(int i=0;i<100;i++){  System.out.println("自定义线程"+i)  }  }  public static void main(String[] args){  Demo d = new Demo();  Thread thread = new Thread(d);  thread .start(); //调用start方法开启线程  for(int i=0;i<100;i++){  System.out.println("main线程"+i)  }  }  }  继承Thread和实现Runnable的区别:  前者是创建不同任务类实例执行各个线程,不能共享数据;  后者是一个任务类实例创建不同线程传入同一任务类实例,共享资源。
方式三:实现Callable接口  Callable是类似于Runnable的接口,实现Callable接口的类和实现Runnable的类都是可被其它线程执行的任务。  * Callable和Runnable有几点不同:  * (1)Callable规定的方法是call(),而Runnable规定的方法是run().  * (2)Callable的任务执行后可返回值,而Runnable的任务是不能返回值的。  * (3)call()方法可抛出异常,而run()方法是不能抛出异常的,只能在内部消化。  * (4)运行Callable任务可拿到一个Future对象, Future 表示异步计算的结果。它提供了检查计算是否完成的方法,以等待计算的完成,并检索计算的结果。通过Future对象可了解任务执行情况,可取消任务的执行,还可获取任务执行的结果。
线程的三种创建方式以及相关区别  熟悉三种创建线程方式以及区别  参考:  java创建线程的三种方式及其对比_longshengguoji的专栏-CSDN博客_创建线程的三种方法  创建:  Callable:  (1)创建Callable接口的实现类,并实现call()方法,该call()方法将作为线程执行体,并且有返回值。  (2)创建Callable实现类的实例,使用FutureTask类来包装Callable对象,该FutureTask对象封装了该Callable对象的call()方法的返回值。  (3)使用FutureTask对象作为Thread对象的target创建并启动新线程。
(4)调用FutureTask对象的get()方法来获得子线程执行结束后的返回值  //CallableThreadTest implments Callable<Integer>CallableThreadTestctt=newCallableThreadTest();FutureTask<Integer>ft=newFutureTask<>(ctt);newThread(ft,"name").start();ft.get();//获取返回值  不使用get方法获取返回值时,不会捕捉到异常。  这种问题出现主要时代码规范问题,不获取返回值直接使用runnable中try…catch代替即可。
执行Runnable任务如果发生异常,主线程无法知晓;而执行Callable任务如果发生异常,在Future.get()时会抛出java.util.concurrent.ExecutionException,其中封装了真实异常  publicstaticvoidmain(String[]args)throwsInterruptedException{Callablec=()->{System.out.println(100);thrownewException();};try{FutureTaskft=newFutureTask(c);Threadt=newThread(ft);t.start();ft.get();}catch(Exceptione){System.out.println("have a Exception");}}}  区别:  采用实现Runnable、Callable接口的方式创见多线程时,优势是:  java只支持单继承,还可以继承其他类。
通过实现的方式,多个线程可以共享同一个target对象,所以非常适合多个相同线程来处理同一份资源的情况,从而可以将CPU、代码和数据分开,形成清晰的模型,较好地体现了面向对象的思想。  Testt1=newTest();newThread(t1,"惠").start();newThread(t1,"夸宝").start();newThread(t1,"阿离").start();Testt1=newTest();t1.start();Testt2=newTest();t2.start();  Callable方式能抛出异常,为什么实例Runnable接口时,run方法不能抛出异常?。(多态)  Callable方式能抛出异常,为什么实例Runnable接口时,run方法不能抛出异常?。  [为什么子类继承父类方法之后,不能抛出比父类更多的异常]   1. **子类在覆盖父类时,**如果父类的方法抛出异常,那么子类的覆盖方法,只能抛出父类的异常或者该异常的子类。或者不抛。
2. 如果父类或者接口的方法中,没有异常抛出,那么子类在覆盖方法时,也不可以抛出异常。发生异常必须进行try处理。  run方法在Thread类中,或者Runnable中都没有抛出异常,所以在继承Thread类或者实现Runnable的时候也不能抛出异常。  只能修改父类来进行抛出异常,但无法修改。  callable方式可以有返回值  劣势:  访问当前线程只能通过Thread.currentThread(),而extends直接用this即可。  Executors:  https://www.baidu.com/s?
ie=UTF-8&wd=executors%E5%9B%9B%E7%A7%8D%E5%88%9B%E5%BB%BA%E6%96%B9%E5%BC%8F  https://www.cnblogs.com/ljp-sun/p/6580147.html:  Java通过Executors提供四种线程池,分别为:  newCachedThreadPool创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。  newFixedThreadPool创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列中等待。  newScheduledThreadPool创建一个定长线程池,支持定时及周期性任务执行。  newSingleThreadExecutor创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
多线程 三种创建方式及区别  线程概念  进程:启动一个程序就是一个进程。  线程:在一个程序里面,多个事情同步进行,这个事情是由线程来完成  不使用多线程的效果  如果我们不使用线程,会怎么样呢?
看下面代码  新建立一个hero类包含英雄的name,血量,攻击力,内置一个攻击方法  packagecharactor;importjava.io.Serializable;publicclassHero{publicString name;publicfloathp;publicintdamage;publicvoidattackHero(Hero h){try{//为了表示攻击需要时间,每次攻击暂停1000毫秒Thread.sleep(1000);}catch(InterruptedExceptione){e.printStackTrace();}h.hp-=damage;System.out.format("%s 正在攻击 %s, %s的血变成了 %.0f%n",name,h.name,h.name,h.hp);if(h.isDead())System.out.println(h.name+"死了!");}publicbooleanisDead(){return0>=hp?
但是run()方法是不能直接被调用的,这里涉及到操作系统的资源调度问题。要想要启动多线程必须使用start()方法完成(public void start()).  虽然调用的是start()方法,但是最终执行的是run()方法,并且所有的线程是交替执行的。  在JAVA执行过程之中考虑到对于不同层次的开发者的需求,所以其支持有本地的操作系统函数调用,而这项技术就被称为JNI(java本地接口)技术。利用这项技术可以使用一些操作系统提供的底层函数进行一些特殊处理,而在Thread类里面提供的start0()就表示需要将此方法依赖于不同的操作系统实现。  *.class在jvm中执行  任何情况下,只要定义了多线程,多线程的启动永远只有一种方案:Thread类中的start()方法。
必须,借助一个线程对象的start()方法,才会启动一个新的线程。  所以,在创建Thread对象的时候,把battle1作为构造方法的参数传递进去,这个线程启动的时候,就会去执行battle1.run()方法了  3. 匿名类  使用匿名类,继承Thread,重写run方法,直接在run方法中写业务代码匿名类的一个好处是可以很方便的访问外部的局部变量。  前提是外部的局部变量需要被声明为final。
Java并发编程——创建线程的三种方法以及区别  Java使用Thread类代表线程,所有的线程对象都必须是Thread类或其子类的实例。Java可以用三种方式来创建线程,如下所示:  继承Thread类创建线程  实现Runnable接口创建线程  使用Callable和Future创建线程  下面让我们分别来看看这三种创建线程的方法。  ------------------------继承Thread类创建线程---------------------  通过继承Thread类来创建并启动多线程的一般步骤如下  1】定义Thread类的子类,并重写该类的run()方法,该方法的方法体就是线程需要完成的任务,run()方法也称为线程执行体。
call()方法可以有返回值  call()方法可以声明抛出异常  Java5提供了Future接口来代表Callable接口里call()方法的返回值,并且为Future接口提供了一个实现类FutureTask,这个实现类既实现了Future接口,还实现了Runnable接口,因此可以作为Thread类的target。在Future接口里定义了几个公共方法来控制它关联的Callable任务。
boolean cancel(boolean mayInterruptIfRunning):视图取消该Future里面关联的Callable任务  get():返回Callable里call()方法的返回值,调用这个方法会导致程序阻塞,必须等到子线程结束后才会得到返回值  get(long timeout,TimeUnit unit):返回Callable里call()方法的返回值,最多阻塞timeout时间,经过指定时间没有返回抛出TimeoutException  boolean isDone():若Callable任务完成,返回True  boolean isCancelled():如果在Callable任务正常完成前被取消,返回True  介绍了相关的概念之后,创建并启动有返回值的线程的步骤如下:  1】创建Callable接口的实现类,并实现call()方法,然后创建该实现类的实例(从java8开始可以直接使用Lambda表达式创建Callable对象)。
public interface Callable<V> {  V call() throws Exception;  }  Java5提供了Future接口来接收Callable接口中call()方法的返回值。 Callable接口是 Java5 新增的接口,不是Runnable接口的子接口,所以Callable对象不能直接作为Thread对象的target。针对这个问题,引入了RunnableFuture接口,RunnableFuture接口是Runnable接口和Future接口的子接口,可以作为Thread对象的target 。同时,Java5提供了一个RunnableFuture接口的实现类:FutureTask ,FutureTask可以作为Thread对象的target。
【JAVA】创建线程的三种方法以及区别  线程有 6 种线程状态:new(新建)、runnnable(可运行)、blocked(阻塞)、waiting(等待)、time waiting (定时等待)和 terminated(终止)。  创建线程的三种方法  1)继承Thread类,重写run方法  2)实现Runnable接口创建线程  3)使用Callable和Future创建线程  下面让我们分别来看看这三种创建线程的方法。  ------------------------继承Thread类创建线程---------------------  通过继承Thread类来创建并启动多线程的一般步骤如下  1】定义Thread类的子类,并重写该类的run()方法,该方法的方法体就是线程需要完成的任务,run()方法也称为线程执行体。
2】创建Thread子类的实例,也就是创建了线程对象  3】启动线程,即调用线程的start()方法  代码实例  ------------------------实现Runnable接口创建线程---------------------  通过实现Runnable接口创建并启动线程一般步骤如下:  1】定义Runnable接口的实现类,一样要重写run()方法,这个run()方法和Thread中的run()方法一样是线程的执行体  2】创建Runnable实现类的实例,并用这个实例作为Thread的target来创建Thread对象,这个Thread对象才是真正的线程对象  3】第三部依然是通过调用线程对象的start()方法来启动线程  代码实例  ------------------------使用Callable和Future创建线程---------------------  和Runnable接口不一样,Callable接口提供了一个call()方法作为线程执行体,call()方法比run()方法功能要强大。
2、这种方式下,多个线程可以共享一个target对象,非常适合多线程处理同一份资源的情形。  3、但是编程稍微复杂,如果需要访问当前线程,必须调用Thread.currentThread()方法。  4、继承Thread类的线程类不能再继承其他父类(Java单继承决定)。  注:一般推荐采用实现接口的方式来创建多线程  ------------------------java终止线程的三种方式---------------------  在java中有三种方式可以终止线程。分别为:  使用退出标志,使线程正常退出,也就是当run方法完成后线程终止。  使用stop方法强行终止线程(这个方法不推荐使用,因为stop和suspend、resume一样,也可能发生不可预料的结果)。  使用interrupt方法中断线程。  下面我们来详细的介绍这三种方法。  使用退出标志终止线程  当run方法执行完后,线程就会退出。但有时run方法是永远不会结束的。如在服务端程序中使用线程进行监听客户端请求,或是其他的需要循环处理的任务。
在这种情况下,一般是将这些任务放在一个循环中,如while循环。如果想让循环永远运行下去,可以使用while(true){……}来处理。但要想使while循环在某一特定条件下退出,最直接的方法就是设一个boolean类型的标志,并通过设置这个标志为true或false来控制while循环是否退出。下面给出了一个利用退出标志终止线程的例子。
packagechapter2;publicclassThreadFlagextendsThread{publicvolatilebooleanexit=false;publicvoidrun(){while(!exit);}publicstaticvoidmain(String[]args)throwsException{ThreadFlagthread=newThreadFlag();thread.start();sleep(5000);// 主线程延迟5秒thread.exit=true;// 终止线程threadthread.join();System.out.println("线程退出!");}}  在上面代码中定义了一个退出标志exit,当exit为true时,while循环退出,exit的默认值为false,在定义exit时,使用了一个Java关键字volatile,这个关键字的目的是使exit同步,也就是说在同一时刻只能由一个线程来修改exit的值。
使用stop方法终止线程  使用stop方法可以强行终止正在运行或挂起的线程。我们可以使用如下的代码来终止线程:  虽然使用上面的代码可以终止线程,但使用stop方法是很危险的,就象突然关闭计算机电源,而不是按正常程序关机一样,可能会产生不可预料的结果,因此,并不推荐使用stop方法来终止线程。  使用interrupt方法终止线程,使用interrupt方法来终端线程可分为两种情况:  (1)线程处于阻塞状态,如使用了sleep方法。  (2)使用while(!isInterrupted()){……}来判断线程是否被中断。  在第一种情况下使用interrupt方法,sleep方法将抛出一个InterruptedException,而在第二种情况下线程将直接退出。下面的代码演示了在第一种情况下使用interrupt方法。
创建线程的三种方式和区别(转)  今天面试的时候被问到这个题目,当时确实很懵逼,现在想想从三种方法的实现角度可以推断出来。  第一种创建方式:  继承Thread,并且重写run方法。  [java]view plaincopy  packagecom.easytopit.thread;  publicclassExtendsThreadextendsThread {  @Override  publicvoidrun() {  for(inti =1;i<=100;i++){  System.out.println("使用继承Thread的方法====="+i);  }  }  }  第二种创建方式(一般用的最多):  实现Runable接口,并且重写run方法。
创建线程的三种不同方式  转载,来自:(https://thispointer.com/c-11-multithreading-part-1-three-different-ways-to-create-threads/)  C ++ 11多线程–第1部分:创建线程的三种不同方式  在本文中,我们将讨论如何使用std :: thread在C ++ 11中创建线程。  C ++ 11线程库简介  原始C ++标准仅支持单线程编程。新的C ++标准(称为C ++ 11或C ++ 0x)于2011年发布。在C ++ 11中,引入了新的线程库。  要求的编译器:  Linux: gcc 4.8.1(完全并发支持)  Windows: Visual Studio 2012和MingW  如何在Linux上编译: g ++ –std = c ++ 11 sample.cpp -lpthread  C ++ 11中的线程创建  在每个C ++应用程序中,都有一个默认的主线程,即main()函数。
在C ++ 11中,我们可以通过创建std :: thread类的对象来创建其他线程。  每个std :: thread对象都可以与一个线程关联。  标头要求:  #include <thread>  1  std :: thread在构造函数中接受什么?  我们可以在std :: thread对象上附加一个回调,该回调将在新线程启动时执行。这些回调可以是  1.)函数指针  2.)函数对象  3.)Lambda函数  可以这样创建线程对象,  std::threadthObj(<CALLBACK>);  1  新线程将在创建新对象后立即启动,并将与启动它的线程并行执行传递的回调。  此外,任何线程都可以通过在该线程的对象上调用join()函数来等待另一个线程退出。  让我们看一个示例,其中主线程将创建一个单独的线程。创建此新线程后,主线程将在控制台上打印一些数据,然后等待新创建的线程退出。
std :: thread :: id是一个Object,它也可以比较并在控制台上打印。
创建线程的三种方法以及区别  使用多线程的原因:  很多时候,仅仅使用单一的线程就能完成很多需要做的工作;但是,在 web 中,单一线程执行是很明显的行不通的。例如,一个用户请求了一个耗时很长的操作;那么其他用户的请求就无法得到处理和响应了,这样的工作效率极其低下。可以看出,使用多线程很多时候是为了合理地充分利用计算机资源,提高运行效率,以便带来更好的服务体验。  需要注意的是,对于单处理器来讲,如果某个任务没有阻塞的相关操作,使用多线程反而会增加更多的上下午切换的开销;此时,只有存在某个阻塞请求可能耗时较长时,才会把它们分割为多个线程执行。  有时候,你无法选择何时在你的程序中使用多线程。例如,在 web 系统中:基本的 web 库件、Servlet 都具有天生的多线程性。因此,在开发过程中,当某一个任务顺序执行的时间较长,而且后续操作不过分依赖之前操作的结果,此时应当考虑分割成多个子任务执行。
线程的基本特点:  一个进程可以含有多个线程:  分享CPU(并发或以时间片的方式)  共享内存(多个线程访问同一个对象)  Java 从语言的级别支持多线程(每一个进程都拥有创建多个线程的能力):  Object 的 wait ()、notify ()  java.lang 中的类 Thread  java 中创建线程的三种方法以及区别  Java 使用 Thread 类代表线程,所有的线程对象都必须是 Thread 类或其子类的实例。Java 可以用三种方式来创建线程,如下所示:  1)继承 Thread 类创建线程  2)实现 Runnable 接口创建线程  3)使用 Callable 和 Future 创建线程  下面让我们分别来看看这三种创建线程的方法。
------------------------ 继承 Thread 类创建线程 ---------------------  通过继承 Thread 类来创建并启动多线程的一般步骤如下:  1】d 定义 Thread 类的子类,并重写该类的run()方法,该方法的方法体就是线程需要完成的任务,run () 方法也称为线程执行体。
call () 方法可以有返回值  call () 方法可以声明抛出异常  Java5 提供了 Future 接口来代表 Callable 接口里 call () 方法的返回值,并且为 Future 接口提供了一个实现类 FutureTask,这个实现类既实现了 Future 接口,还实现了 Runnable 接口,因此可以作为 Thread 类的 target。在 Future 接口里定义了几个公共方法来控制它关联的 Callable 任务。
java创建多线程的四种方式及其区别  java创建多线程有如下四种方式:  继承Thread类创建线程  实现Runnable接口创建线程  使用Callable和Future创建线程  使用线程池创建(使用java.util.concurrent.Executor接口)  下面分别介绍这四种创建多线程的方式  1. ----------------------继承Thread类创建线程--------------------------------  通过继承Thread类来创建并启动多线程的一般步骤如下:  1】定义Tread类的子类MyThread,并重写run()方法.run()方法的方法体(线程执行体)就是线程要执行的任务。
3--------------------------覆写Callable接口实现多线程------------------------------------  和Runnable接口不一样,Callable接口提供了一个call()方法作为线程执行体,call()方法比run()方法功能要强大:  1>call方法可以有返回值  2>call()方法可以声明抛出异常  Java5提供了Future接口来代表Callable接口里call()方法的返回值,并且为Future接口提供了一个实现类FutureTask,这个实现类既实现了Future接口,还实现了Runnable接口,因此可以作为Thread类的target。在Future接口里定义了几个公共方法来控制它关联的Callable任务。
>boolean cancel(boolean mayInterruptIfRunning):视图取消该Future里面关联的Callable任务  >V get():返回Callable里call()方法的返回值,调用这个方法会导致程序阻塞,必须等到子线程结束后才会得到返回值  >V get(long timeout,TimeUnit unit):返回Callable里call()方法的返回值,最多阻塞timeout时间,经过指定时间没有返回抛出TimeoutException  >boolean isDone():若Callable任务完成,返回True  >boolean isCancelled():如果在Callable任务正常完成前被取消,返回True  介绍了相关的概念之后,创建并启动有返回值的线程的步骤如下:  1】创建Callable接口的实现类,并实现call()方法,然后创建该实现类的实例(从java8开始可以直接使用Lambda表达式创建Callable对象)。
java 创建线程的三种方式、创建线程池的四种方式  概要:  java创建线程的三种方式:  继承Thread类创建线程类  实现Runnable接口  通过Callable和Future创建线程  java创建线程池的四种方式:  newCachedThreadPool创建一个可缓存的线程池,如果线程池长度超过处理需求,可灵活回收空闲线程,若无可回收,则新建线程  newFixedThreadPool创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列中等待  newScheduledThreadPool创建一个定长线程池,支持定时及周期性任务执行  newSingleThreadExecutor创建一个单线程化的线程池,它只会唯一的工作线程来执行任务,保证所有任务按照指定  顺序(FIFO,LIFO,优先级)执行  线程池的优点:  a.重用存在的线程,减少对象创建、消亡的开销,性能佳。  b. 可有效控制最大并发线程数,提高系统资源的使用率,同时避免过多资源竞争,避免堵塞。
c. 提供定时执行、定期执行、单线程、并发数控制等功能。  第一Java中创建线程主要有三种方式:  1、继承Thread类创建线程类 (extends)  (1)定义Thread类的子类,并重写该类的run方法,该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体(线程体)。  (2)创建Thread子类的实例,即创建了线程对象。  (3)调用线程对象的start()方法来启动该线程。
publicclassFirstThreadTestextendsThread{inti=0;//重写run方法,run方法的方法体就是现场执行体publicvoidrun(){for(;i<100;i++){ log.info(getName()+" "+i); } }publicstaticvoidmain(String[] args){for(inti=0;i<100;i++) { log.info(Thread.currentThread().getName()+" : "+i);if(i==20) {newFirstThreadTest().start();newFirstThreadTest().start(); } } } }  上述代码中Thread.currentThread()方法返回当前正在执行的线程对象。GetName()方法返回调用该方法的线程的名字。  2、通过Runnable接口创建线程类  (1)定义runnable接口的实现类,并重写该接口的run()方法,该run()方法的方法体同样是该线程的线程执行体。
(2)创建 Runnable实现类的实例,并以此实例作为Thread的target来创建Thread对象,该Thread对象才是真正的线程对象。  (3)调用线程对象的start()方法来启动该线程。
publicclassRunnableThreadTestimplementsRunnable{privateinti;publicvoidrun(){for(i =0;i <100;i++) { log.info(Thread.currentThread().getName()+" "+i); } }publicstaticvoidmain(String[] args){for(inti=0;i <100;i++) { log.info(Thread.currentThread().getName()+" "+i);if(i==20) { RunnableThreadTest runner=newRunnableThreadTest();newThread(runner,"新线程1").start();newThread(runner,"新线程2").start(); } } } }  线程的执行流程很简单,当执行代码start()时,就会执行对象中重写的void run()方法,该方法执行完成后,线程就消亡了。
3、通过Callable和Future创建线程  (1)创建Callable接口的实现类,并实现call()方法,该call()方法将作为线程执行体,并且有返回值。  publicinterfaceCallable{ Vcall()throwsException; }  (2)创建Callable实现类的实例,使用FutureTask类来包装Callable对象,该FutureTask对象封装了该Callable对象的call()方  法的返回值。(FutureTask是一个包装器,它通过接受Callable来创建,它同时实现了Future和Runnable接口。)  (3)使用FutureTask对象作为Thread对象的target创建并启动新线程。
在这种方式下,多个线程可以共享同一个target对象,所以非常适合多个相同线程来处理同一份资源的情况,从而可以将CPU、代码和数据分开,形成清晰的模型,较好地体现了面向对象的思想。  劣势:  编程稍微复杂,如果要访问当前线程,则必须使用Thread.currentThread()方法。  2、使用继承Thread类的方式创建多线程  优势:  编写简单,如果需要访问当前线程,则无需使用Thread.currentThread()方法,直接使用this即可获得当前线程。  劣势:  线程类已经继承了Thread类,所以不能再继承其他父类。  3、Runnable和Callable的区别  (1) Callable规定(重写)的方法是call(),Runnable规定(重写)的方法是run()。  (2)Callable的任务执行后可返回值,而Runnable的任务是不能返回值的。  (3)call方法可以抛出异常,run方法不可以。  (4) 运行Callable任务可以拿到一个Future对象,表示异步计算的结果。
它提供了检查计算是否完成的方法,以等待计算的  完成,并检索计算的结果。通过Future对象可以了解任务执行情况,可取消任务的执行,还可获取执行结果future.get()。  第二 创建四种线程池的方式  1、new Thread的弊端  执行一个异步任务你还只是如下new Thread吗?  newThread(newRunnable() {@Overridepublicvoidrun(){// TODO Auto-generated method stub} } ).start();  那你就out太多了,new Thread的弊端如下:  a. 每次new Thread新建对象性能差。  b. 线程缺乏统一管理,可能无限制新建线程,相互之间竞争,及可能占用过多系统资源导致死机或oom(out of memory)。  c. 缺乏更多功能,如定时执行、定期执行、线程中断。  相比new Thread,Java提供的四种线程池的好处在于:  a.重用存在的线程,减少对象创建、消亡的开销,性能佳。
b. 可有效控制最大并发线程数,提高系统资源的使用率,同时避免过多资源竞争,避免堵塞。  c. 提供定时执行、定期执行、单线程、并发数控制等功能。  2、Java 线程池  Java通过Executors提供四种线程池,分别为:  newCachedThreadPool创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。  newFixedThreadPool创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列中等待。  newScheduledThreadPool创建一个定长线程池,支持定时及周期性任务执行。  newSingleThreadExecutor创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。  (1) newCachedThreadPool:  创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。
示例代码如下:  ExecutorServicecachedThreadPool=Executors.newCachedThreadPool();for(inti=0; i <10; i++) {finalintindex=i;try{ Thread.sleep(index *1000); }catch(InterruptedException e) { e.printStackTrace(); } cachedThreadPool.execute(newRunnable() {@Overridepublicvoidrun(){ log.info(index); } }); }  线程池为无限大,当执行第二个任务时第一个任务已经完成,会复用执行第一个任务的线程,而不用每次新建线程。  (2) newFixedThreadPool:--- 需要指定线程池的大小  创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列中等待。
java创建线程的三种方式及其对比  Java中创建线程主要有三种方式:  一、继承Thread类创建线程类  (1)定义Thread类的子类,并重写该类的run方法,该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。  (2)创建Thread子类的实例,即创建了线程对象。  (3)调用线程对象的start()方法来启动该线程。
packagecom.thread;  publicclassFirstThreadTestextendsThread{  inti=0;  //重写run方法,run方法的方法体就是现场执行体  publicvoidrun()  {  for(;i<100;i++){  System.out.println(getName()+" "+i);  }  }  publicstaticvoidmain(String[] args)  {  for(inti=0;i<100;i++)  {  System.out.println(Thread.currentThread().getName()+" : "+i);  if(i==20)  {  newFirstThreadTest().start();  newFirstThreadTest().start();  }  }  }  }  上述代码中Thread.currentThread()方法返回当前正在执行的线程对象。GetName()方法返回调用该方法的线程的名字。
二、通过Runnable接口创建线程类  (1)定义runnable接口的实现类,并重写该接口的run()方法,该run()方法的方法体同样是该线程的线程执行体。  (2)创建 Runnable实现类的实例,并依此实例作为Thread的target来创建Thread对象,该Thread对象才是真正的线程对象。  (3)调用线程对象的start()方法来启动该线程。
线程的三种创建方式详解  一、线程与进程的理解:  进程:  进程是程序在并发执行过程中操作系统分配和管理资源的基本单位。也就是资源分配与管理的最小单位,进程也可理解为一个正在运行中的应用程序。一个进程由一个或者多个线程组成。  线程:  线程是任务调度和执行的最小单位。  线程和进程之间的区别:  1.同一进程的所有线程共享该进程的地址空间。但是不同进程之间的地址空间是隔离的,也就是我们所说的独立的;  2.同一进程之间的所有线程共享该进程的资源,比如cpu,内存,io等等,进程之间的资源是独立的,非共享的。这一点跟上述的地址空间的分配有点类似。  3.每一个进程是独立的,都拥有自己 的程序执行入口,顺序执行序列。但是线程不能独立执行,必须依赖于进程,也就是正在执行的应用程序。  4.由于同一进程之间的所有线程共享资源的特性,当一个线程发生奔溃时,它的进程也会发生奔溃,但不会影响到其他进程。因为进程之间的资源分配是独立的。  二、线程的生命周期:  一个线程的生命周期分为五个状态,分别是新建状态、就绪状态、运行状态、阻塞状态、死亡状态。
新建状态:一个新的线程被创建出来,但是还没有调用start方法。  就绪状态:指一个新建的线程,执行了start方法,使线程变的可运行。  运行状态:指一个线程执行了run方法。  阻塞状态:由于一个线程的时间片用完了,该线程从运行状态进入休眠状态,让出cpu资源。当时间间隔到期或者等待的事件发生了,该状态的线程切换到可运行状态。  死亡状态:一个运行状态的线程完成任务或者其他终止条件发生,该线程就切换到死亡状态。  三、java线程的三种创建方法:  通过继承Thread类实现;  通过实现Runnable接口实现;  通过Callable接口和FutureTask 类接口创建线程;  1.通过继承Thread类实现;  首先先创建一个类,将该类继承Thread类,然后创建一个该类的实例。  继承类必须重写run()方法,该方法是新线程的入口点。它也必须调用start()方法才能执行。该方法尽管被列为一种多线程实现方式。  下面是一个实例,创建一个新的线程并执行它。
2.通过实现Runnable接口来实现线程的创建:  创建一个线程,最简单的方法是创建一个实现Runnable接口的类。  为了实现Runnable,一个类只需要执行一个方法调用run(),声明如下:  publicvoidrun()  然后在通过Thread类对象调用start()方法。使线程进入到可运行状态。
创建线程的三种方式(Thread、Runnable、Callable)  方式一:继承Thread类实现多线程:  1. 在Java中负责实现线程功能的类是java.lang.Thread 类。  2. 可以通过创建 Thread的实例来创建新的线程。  3. 每个线程都是通过某个特定的Thread对象所对应的方法run( )来完成其操作的,方法run( )称为线程体。  4. 通过调用Thread类的start()方法来启动一个线程(只是将线程由新生态转为就绪态,而不是运行态)。
代码示例:  1publicclassTestThreadextendsThread {//自定义类继承Thread类2//run()方法里是线程体3publicvoidrun() {4for(inti = 0; i < 10; i++) {5System.out.println(this.getName() + ":" + i);//getName()方法是返回线程名称6}7}89publicstaticvoidmain(String[] args) {10TestThread thread1 =newTestThread();//创建线程对象11thread1.start();//启动线程12TestThread thread2 =newTestThread();13thread2.start();14}15}  此种方式的缺点:因为Java只支持单继承多实现,所以当我们的类已经继承了一个类(如小程序必须继承自 Applet 类),则无法再继承 Thread 类。
方式二:通过Runnable接口实现多线程  在开发中,我们应用更多的是通过Runnable接口实现多线程。这种方式克服了实现Thread类的缺点,即在实现Runnable接口的同时还可以继承某个类。
如果需要获取执行结果,就必须通过共享变量或者使用线程通信的方式来达到效果,这样使用起来就比较麻烦。  而自从Java 1.5开始,就提供了Callable和Future,通过它们可以在任务执行完毕之后得到任务执行结果。  Callable和Future介绍  Callable接口代表一段可以调用并返回结果的代码;Future接口表示异步任务,是还没有完成的任务给出的未来结果。所以说Callable用于产生结果,Future用于获取结果。  Callable接口使用泛型去定义它的返回类型。Executors类提供了一些有用的方法在线程池中执行Callable内的任务。由于Callable任务是并行的(并行就是整体看上去是并行的,其实在某个时间点只有一个线程在执行),我们必须等待它返回的结果。  java.util.concurrent.Future对象为我们解决了这个问题。在线程池提交Callable任务后返回了一个Future对象,使用它可以知道Callable任务的状态和得到Callable返回的执行结果。
Future提供了get()方法让我们可以等待Callable结束并获取它的执行结果。  Callable与Runnable  java.lang.Runnable吧,它是一个接口,在它里面只声明了一个run()方法:  1publicinterfaceRunnable {2publicabstractvoidrun();3}  由于run()方法返回值为void类型,所以在执行完任务之后无法返回任何结果。
Callable位于java.util.concurrent包下,它也是一个接口,在它里面也只声明了一个方法,只不过这个方法叫做call():  1publicinterfaceCallable<V>{2/**3* Computes a result, or throws an exception if unable to do so.4*5*@returncomputed result6*@throwsException if unable to compute a result7*/8V call()throwsException;9}  可以看到,这是一个泛型接口,call()函数返回的类型就是传递进来的V类型。  那么怎么使用Callable呢?
一般情况下是配合ExecutorService来使用的,在ExecutorService接口中声明了若干个submit方法的重载版本:  <T> Future<T> submit(Callable<T>task);<T> Future<T>submit(Runnable task, T result); Future<?> submit(Runnable task);  第一个submit方法里面的参数类型就是Callable。  暂时只需要知道Callable一般是和ExecutorService配合来使用的,具体的使用方法讲在后面讲述。  一般情况下我们使用第一个submit方法和第三个submit方法,第二个submit方法很少使用。  Future  Future就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果。必要时可以通过get方法获取执行结果,该方法会阻塞直到任务返回结果。
Future类位于java.util.concurrent包下,它是一个接口:  1publicinterfaceFuture<V>{2booleancancel(booleanmayInterruptIfRunning);3booleanisCancelled();4booleanisDone();5V get()throwsInterruptedException, ExecutionException;6V get(longtimeout, TimeUnit unit)7throwsInterruptedException, ExecutionException, TimeoutException;8}  在Future接口中声明了5个方法,下面依次解释每个方法的作用:  cancel方法用来取消任务,如果取消任务成功则返回true,如果取消任务失败则返回false。参数mayInterruptIfRunning表示是否允许取消正在执行却没有执行完毕的任务,如果设置true,则表示可以取消正在执行过程中的任务。
如果任务已经完成,则无论mayInterruptIfRunning为true还是false,此方法肯定返回false,即如果取消已经完成的任务会返回false;如果任务正在执行,若mayInterruptIfRunning设置为true,则返回true,若mayInterruptIfRunning设置为false,则返回false;如果任务还没有执行,则无论mayInterruptIfRunning为true还是false,肯定返回true。  isCancelled方法表示任务是否被取消成功,如果在任务正常完成前被取消成功,则返回 true。  isDone方法表示任务是否已经完成,若任务完成,则返回true;  get()方法用来获取执行结果,这个方法会产生阻塞,会一直等到任务执行完毕才返回;  get(long timeout, TimeUnit unit)用来获取执行结果,如果在指定时间内,还没获取到结果,就直接返回null。
也就是说Future提供了三种功能:  1)判断任务是否完成;  2)能够中断任务;  3)能够获取任务执行结果。  因为Future只是一个接口,所以是无法直接用来创建对象使用的,因此就有了下面的FutureTask。  FutureTask  FutureTask实现了RunnableFuture接口,这个接口的定义如下:  publicinterfaceRunnableFuture<V>extendsRunnable, Future<V>{voidrun(); }  可以看到这个接口实现了Runnable和Future接口,接口中的具体实现由FutureTask来实现。
这个类的两个构造方法如下 :  1publicFutureTask(Callable<V>callable) {2if(callable ==null)3thrownewNullPointerException();4sync =newSync(callable);5}6publicFutureTask(Runnable runnable, V result) {7sync =newSync(Executors.callable(runnable, result));8}  如上提供了两个构造函数,一个以Callable为参数,另外一个以Runnable为参数。这些类之间的关联对于任务建模的办法非常灵活,允许你基于FutureTask的Runnable特性(因为它实现了Runnable接口),把任务写成Callable,然后封装进一个由执行者调度并在必要时可以取消的FutureTask。  FutureTask可以由执行者调度,这一点很关键。
它对外提供的方法基本上就是Future和Runnable接口的组合:get()、cancel、isDone()、isCancelled()和run(),而run()方法通常都是由执行者调用,我们基本上不需要直接调用它。
在很多情况下主线程生成并起动了子线程如果子线程里要进行大量的耗时的运算主线程往往将于子线程之前结束但是如果主线程处理完其他的事务后需要用到子线程的处理结果也就是主线程需要等待子线程执行完成之后再结束这个时候就要用到join方法了  【JAVA】创建线程的三种方法以及区别  线程有 6 种线程状态:new(新建)、runnnable(可运行)、blocked(阻塞)、waiting(等待)、time waiting (定时等待)和 terminated(终止)。  创建线程的三种方法 1)继承Thread类,重写run方法 2)实现Runnable接口创建线程 3)使用Callable和Future创建线程  下面让我们分别来看看这三种创建线程的方法。
------------------------继承Thread类创建线程--------------------通过继承Thread类来创建并启动多线程的一般步骤如下 1】定义Thread类的子类,并重写该类的run()方法,该方法的方法体就是线程需要完成的任务,run()方法也称为线程执行体。
call()方法可以有返回值 call()方法可以声明抛出异常 Java5提供了Future接口来代表Callable接口里call()方法的返回值,并且为Future接口提供了一个实现类FutureTask,这个实现类既实现了 Future接口,还实现了Runnable接口,因此可以作为Thread类的target。在Future接口里定义了几个公共方法来控制它关联的Callable任务。
boolean cancel(boolean mayInterruptIfRunning):视图取消该Future里面关联的Callable任务  V get():返回Callable里call()方法的返回值,调用这个方法会导致程序阻塞,必须等到子线程结束后才会得到返回值  V get(long timeout,TimeUnit unit):返回Callable里call()方法的返回值,最多阻塞timeout时间,经过指定时间没有 返回抛出TimeoutException  boolean isDone():若Callable任务完成,返回True  boolean isCancelled():如果在Callable任务正常完成前被取消,返回True  介绍了相关的概念之后,创建并启动有返回值的线程的步骤如下: 1】创建Callable接口的实现类,并实现call()方法,然后创建该实现类的实例(从java8开始可以直接使用Lambda表达式创建Callable对象)。
2、这种方式下,多个线程可以共享一个target对象,非常适合多线程处理同一份资源的情形。 3、但是编程稍微复杂,如果需要访问当前线程,必须调用Thread.currentThread()方法。 4、继承Thread类的线程类不能再继承其他父类(Java单继承决定)。  注:一般推荐采用实现接口的方式来创建多线程  ------------------------java终止线程的三种方式---------------------  在java中有三种方式可以终止线程。分别为: 1. 使用退出标志,使线程正常退出,也就是当run方法完成后线程终止。 2. 使用stop方法强行终止线程(这个方法不推荐使用,因为stop和suspend、resume一样,也可能发生不可预料的结果)。 3. 使用interrupt方法中断线程。  下面我们来详细的介绍这三种方法。  1. 使用退出标志终止线程 当run方法执行完后,线程就会退出。但有时run方法是永远不会结束的。如在服务端程序中使用线程进行监听客户端请求,或是其他的需要循 环处理的任务。
在这种情况下,一般是将这些任务放在一个循环中,如while循环。如果想让循环永远运行下去,可以使用while(true) {……}来处理。但要想使while循环在某一特定条件下退出,最直接的方法就是设一个boolean类型的标志,并通过设置这个标志为true或false 来控制while循环是否退出。下面给出了一个利用退出标志终止线程的例子。
2. 使用stop方法终止线程 使用stop方法可以强行终止正在运行或挂起的线程。我们可以使用如下的代码来终止线程: thread.stop();  虽然使用上面的代码可以终止线程,但使用stop方法是很危险的,就象突然关闭计算机电源,而不是按正常程序关机一样,可能会产生不可预料 的结果,因此,并不推荐使用stop方法来终止线程。  3. 使用interrupt方法终止线程,使用interrupt方法来终端线程可分为两种情况: (1)线程处于阻塞状态,如使用了sleep方法。 (2)使用while(!isInterrupted()){……}来判断线程是否被中断。  在第一种情况下使用interrupt方法,sleep方法将抛出一个InterruptedException,而在第二种情况下线程将直接退出。下面的代码演示了在第 一种情况下使用interrupt方法。
一个是静态的方法interrupted(),一个是非静态的方法 isInterrupted(),这两个方法的区别是interrupted用来判断当前线是否被中断,而isInterrupted可以用来判断其他线程是否被中断。因此,while (!isInterrupted())也可以换成while (!Thread.interrupted())。  为什么要用join()方法 在很多情况下,主线程生成并起动了子线程,如果子线程里要进行大量的耗时的运算,主线程往往将于子线程之前结束,但是如果主线程处理完其 他的事务后,需要用到子线程的处理结果,也就是主线程需要等待子线程执行完成之后再结束,这个时候就要用到join()方法了。
在很多情况下主线程生成并起动了子线程如果子线程里要进行大量的耗时的运算主线程往往将于子线程之前结束但是如果主线程处理完其他的事务后需要用到子线程的处理结果也就是主线程需要等待子线程执行完成之后再结束这个时候就要用到join方法了 【JAVA】创建线程的三种方法以及区别 线程有 6 种线程状态:new(新建)、runnnable(可运行)、blocked(阻塞)、waiting(等待)、time waiting (定时等待)和 terminated(终止)。 创建线程的三种方法 1)继承Thread类,重写run方法 2)实现Runnable接口创建线程 3)使用Callable和Future创建线程 下面让我们分别来看看这三种创建线程的方法。 ------------------------继承Thread类创建线程--------------------通过继承Thread类来创建并启动多线程的一般步骤如下 1】定义Thread类的子类,并重写该类的run()方法,该方法的方法体就是线程需要完成的任务,run()方法也称为线程执行体。
boolean cancel(boolean mayInterruptIfRunning):视图取消该Future里面关联的Callable任务 V get():返回Callable里call()方法的返回值,调用这个方法会导致程序阻塞,必须等到子线程结束后才会得到返回值 V get(long timeout,TimeUnit unit):返回Callable里call()方法的返回值,最多阻塞timeout时间,经过指定时间没有 返回抛出TimeoutException boolean isDone():若Callable任务完成,返回True boolean isCancelled():如果在Callable任务正常完成前被取消,返回True 介绍了相关的概念之后,创建并启动有返回值的线程的步骤如下: 1】创建Callable接口的实现类,并实现call()方法,然后创建该实现类的实例(从java8开始可以直接使用Lambda表达式创建Callable对象)。
2、这种方式下,多个线程可以共享一个target对象,非常适合多线程处理同一份资源的情形。 3、但是编程稍微复杂,如果需要访问当前线程,必须调用Thread.currentThread()方法。 4、继承Thread类的线程类不能再继承其他父类(Java单继承决定)。 注:一般推荐采用实现接口的方式来创建多线程 ------------------------java终止线程的三种方式--------------------- 在java中有三种方式可以终止线程。分别为: 1. 使用退出标志,使线程正常退出,也就是当run方法完成后线程终止。 2. 使用stop方法强行终止线程(这个方法不推荐使用,因为stop和suspend、resume一样,也可能发生不可预料的结果)。 3. 使用interrupt方法中断线程。 下面我们来详细的介绍这三种方法。 1. 使用退出标志终止线程 当run方法执行完后,线程就会退出。但有时run方法是永远不会结束的。如在服务端程序中使用线程进行监听客户端请求,或是其他的需要循 环处理的任务。
2. 使用stop方法终止线程 使用stop方法可以强行终止正在运行或挂起的线程。我们可以使用如下的代码来终止线程: thread.stop(); 虽然使用上面的代码可以终止线程,但使用stop方法是很危险的,就象突然关闭计算机电源,而不是按正常程序关机一样,可能会产生不可预料 的结果,因此,并不推荐使用stop方法来终止线程。 3. 使用interrupt方法终止线程,使用interrupt方法来终端线程可分为两种情况: (1)线程处于阻塞状态,如使用了sleep方法。 (2)使用while(!isInterrupted()){……}来判断线程是否被中断。 在第一种情况下使用interrupt方法,sleep方法将抛出一个InterruptedException,而在第二种情况下线程将直接退出。下面的代码演示了在第 一种情况下使用interrupt方法。
请求出错错误代码503请尝试刷新页面重试  java创 建线程的三种方式及其对比  一、 Java中创建线程主要有三种方式: 1、 继承 Thread类 创建线程类  (1)定义Thread类的子类,并重写该类的run方法,该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。  (2)创建Thread子类的实例,即创建了线程对象。  (3)调用线程对象的start()方法来启动该线程。
package com.thread;  public class FirstThreadTest extends Thread{ int i = 0; //重写run方法,run方法的方法体就是现场执行体 public void run() { for(;i<100;i++){ System.out.println(getName()+" "+i); } } public static void main(String[] args) { for(int i = 0;i< 100;i++) { System.out.println(Thread.currentThread().getName()+" : "+i); if(i==20) { new FirstThreadTest().start(); new FirstThreadTest().start(); } } }  }  上述代码中Thread.currentThread()方法返回当前正在执行的线程对象。GetName()方法返回调用该方法的线程的名字。
2、 通过 Runnable接 口创建线程类  (1)定义runnable接口的实现类,并重写该接口的run()方法,该run()方法的方法体同样是该线程的线程执行体。  (2)创建 Runnable实现类的实例,并以此实例作为Thread的target来创建Thread对象,该Thread对象才是真正的线程对象。  (3)调用线程对象的start()方法来启动该线程。
3、 通过 Callable和 Future创 建线程  (1)创建Callable接口的实现类,并实现call()方法,该call()方法将作为线程执行体,并且有返回值。  public interface Callable { V call() throws Exception; }  (2)创建Callable实现类的实例,使用FutureTask类来包装Callable对象,该FutureTask对象封装了该Callable对象的call()方法的返回值。 (FutureTask是一个包装器,它通过接受Callable来创建,它同时实现了Future和Runnable接口。)  (3)使用FutureTask对象作为Thread对象的target创建并启动新线程。
在这种方式下,多个线程可以共享同一个target对象,所以非常适合多个相同线程来处理同一份资源的情况,从而可以将CPU、代码和数据 分开,形成清晰的模型,较好地体现了面向对象的思想。  劣势是: 编程稍微复杂,如果要访问当前线程,则必须使用Thread.currentThread()方法。   2、使用继承Thread类的方式创建多线程时, 优势是: 编写简单,如果需要访问当前线程,则无需使用Thread.currentThread()方法,直接使用this即可获得当前线程。 劣势是: 线程类已经继承了Thread类,所以不能再继承其他父类。 3、Runnable和Callable的区别 (1) Callable规定(重写)的方法是call(),Runnable规定(重写)的方法是run()。 (2) Callable的任务执行后可返回值,而Runnable的任务是不能返回值的。 (3) call方法可以抛出异常,run方法不可以。 (4) 运行Callable任务可以拿到一个Future对象,表示异步计算的结果。
它提供了检查计算是否完成的方法,以等待计算的完成,并检索计算 的结果。通过Future对象可以了解任务执行情况,可取消任务的执行,还可获取执行结果。  请求出错错误代码503请尝试刷新页面重试 java创 建线程的三种方式及其对比 一、 Java中创建线程主要有三种方式: 1、 继承 Thread类 创建线程类 (1)定义Thread类的子类,并重写该类的run方法,该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。 (2)创建Thread子类的实例,即创建了线程对象。 (3)调用线程对象的start()方法来启动该线程。
package com.thread; public class FirstThreadTest extends Thread{ int i = 0; //重写run方法,run方法的方法体就是现场执行体 public void run() { for(;i<100;i++){ System.out.println(getName()+" "+i); } } public static void main(String[] args) { for(int i = 0;i< 100;i++) { System.out.println(Thread.currentThread().getName()+" : "+i); if(i==20) { new FirstThreadTest().start(); new FirstThreadTest().start(); } } } } 上述代码中Thread.currentThread()方法返回当前正在执行的线程对象。GetName()方法返回调用该方法的线程的名字。
2、 通过 Runnable接 口创建线程类 (1)定义runnable接口的实现类,并重写该接口的run()方法,该run()方法的方法体同样是该线程的线程执行体。 (2)创建 Runnable实现类的实例,并以此实例作为Thread的target来创建Thread对象,该Thread对象才是真正的线程对象。 (3)调用线程对象的start()方法来启动该线程。
3、 通过 Callable和 Future创 建线程 (1)创建Callable接口的实现类,并实现call()方法,该call()方法将作为线程执行体,并且有返回值。 public interface Callable { V call() throws Exception; } (2)创建Callable实现类的实例,使用FutureTask类来包装Callable对象,该FutureTask对象封装了该Callable对象的call()方法的返回值。 (FutureTask是一个包装器,它通过接受Callable来创建,它同时实现了Future和Runnable接口。) (3)使用FutureTask对象作为Thread对象的target创建并启动新线程。
在这种方式下,多个线程可以共享同一个target对象,所以非常适合多个相同线程来处理同一份资源的情况,从而可以将CPU、代码和数据 分开,形成清晰的模型,较好地体现了面向对象的思想。 劣势是: 编程稍微复杂,如果要访问当前线程,则必须使用Thread.currentThread()方法。  2、使用继承Thread类的方式创建多线程时, 优势是: 编写简单,如果需要访问当前线程,则无需使用Thread.currentThread()方法,直接使用this即可获得当前线程。 劣势是: 线程类已经继承了Thread类,所以不能再继承其他父类。 3、Runnable和Callable的区别 (1) Callable规定(重写)的方法是call(),Runnable规定(重写)的方法是run()。 (2) Callable的任务执行后可返回值,而Runnable的任务是不能返回值的。 (3) call方法可以抛出异常,run方法不可以。 (4) 运行Callable任务可以拿到一个Future对象,表示异步计算的结果。
博客园 用户登录 代码改变世界 密码登录 短信登录 忘记登录用户名 忘记密码 记住我 登录 第三方登录/注册 没有账户, 立即注册  创建线程的三种方法详细对比   1、继承Thread类:  步骤:①、定义类继承Thread;   ②、复写Thread类中的run方法; 目的:将自定义代码存储在run方法,让线程运行 ③、调用线程的start方法: 该方法有两步:启动线程,调用run方法。   1 public class ThreadDemo1 {   2   3 public static void main(String[] args) {   4   5   //创建两个线程   6   ThreadDemo td = new ThreadDemo("zhangsan");   7   ThreadDemo tt = new ThreadDemo("lisi");   8   //执行多线程特有方法,如果使用td.run();也会执行,但会以单线程方式执行。
9   td.start();   10   tt.start();   11   //主线程   12   for (int i = 0; i < 5; i++) {   13   System.out.println("main" + ":run" + i);   14   }   15 }   16 }   17 //继承Thread类   18 class ThreadDemo extends Thread{   19   20 //设置线程名称   21 ThreadDemo(String name){   22   super(name);   23 }   24 //重写run方法。   25 public void run(){   26   for(int i = 0; i < 5; i++){   27   System.out.println(this.getName() + ":run" + i); //currentThread() 获取当前线程对象(静态)。 getName() 获取线程名称。
28   }   29 }   30 }   2、实现Runnable接口: 接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为run 的无参方法。   实现步骤: ①、定义类实现Runnable接口   ②、覆盖Runnable接口中的run方法   将线程要运行的代码放在该run方法中。   ③、通过Thread类建立线程对象。   ④、将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。   自定义的run方法所属的对象是Runnable接口的子类对象。所以要让线程执行指定对象的run方法就要先明确 run方法所属对象   ⑤、调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。
public class RunnableDemo { public static void main(String[] args) { RunTest rt = new RunTest(); //建立线程对象 Thread t1 = new Thread(rt); Thread t2 = new Thread(rt); //开启线程并调用run方法。 t1.start(); t2.start(); }  }   //定义类实现Runnable接口 class RunTest implements Runnable{  private int tick = 10; //覆盖Runnable接口中的run方法,并将线程要运行的代码放在该run方法中。
public void run(){  while (true) { if(tick > 0){ System.out.println(Thread.currentThread().getName() + "..." + tick--);   } } } }   3、通过Callable和Future创建线程:  实现步骤:①、创建Callable接口的实现类,并实现call()方法,改方法将作为线程执行体,且具有返回值。   ②、创建Callable实现类的实例,使用FutrueTask类进行包装Callable对象,FutureTask对象封装了Callable对象的 call()方法的返回值   ③、使用FutureTask对象作为Thread对象启动新线程。   ④、调用FutureTask对象的get()方法获取子线程执行结束后的返回值。
1 public class CallableFutrueTest {   2 public static void main(String[] args) {   3   CallableTest ct = new CallableTest();   //创建对象   4   FutureTask<Integer> ft = new FutureTask<Integer>(ct);   //使用FutureTask包装CallableTest对象   5   for(int i = 0; i < 100; i++){   6   //输出主线程   7  博客园 用户登录 代码改变世界 密码登录 短信登录 忘记登录用户名 忘记密码 记住我 登录 第三方登录/注册 没有账户, 立即注册 创建线程的三种方法详细对比  1、继承Thread类:  步骤:①、定义类继承Thread;  ②、复写Thread类中的run方法; 目的:将自定义代码存储在run方法,让线程运行 ③、调用线程的start方法: 该方法有两步:启动线程,调用run方法。
1 public class ThreadDemo1 {  2  3 public static void main(String[] args) {  4  5  //创建两个线程  6  ThreadDemo td = new ThreadDemo("zhangsan");  7  ThreadDemo tt = new ThreadDemo("lisi");  8  //执行多线程特有方法,如果使用td.run();也会执行,但会以单线程方式执行。
9  td.start();  10  tt.start();  11  //主线程  12  for (int i = 0; i < 5; i++) {  13  System.out.println("main" + ":run" + i);  14  }  15 }  16 }  17 //继承Thread类  18 class ThreadDemo extends Thread{  19  20 //设置线程名称  21 ThreadDemo(String name){  22  super(name);  23 }  24 //重写run方法。  25 public void run(){  26  for(int i = 0; i < 5; i++){  27  System.out.println(this.getName() + ":run" + i); //currentThread() 获取当前线程对象(静态)。 getName() 获取线程名称。
28  }  29 }  30 }  2、实现Runnable接口: 接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为run 的无参方法。  实现步骤: ①、定义类实现Runnable接口  ②、覆盖Runnable接口中的run方法  将线程要运行的代码放在该run方法中。  ③、通过Thread类建立线程对象。  ④、将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。  自定义的run方法所属的对象是Runnable接口的子类对象。所以要让线程执行指定对象的run方法就要先明确 run方法所属对象  ⑤、调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。
public class RunnableDemo { public static void main(String[] args) { RunTest rt = new RunTest(); //建立线程对象 Thread t1 = new Thread(rt); Thread t2 = new Thread(rt); //开启线程并调用run方法。 t1.start(); t2.start(); } }  //定义类实现Runnable接口 class RunTest implements Runnable{ private int tick = 10; //覆盖Runnable接口中的run方法,并将线程要运行的代码放在该run方法中。
public void run(){ while (true) { if(tick > 0){ System.out.println(Thread.currentThread().getName() + "..." + tick--);  } } } }  3、通过Callable和Future创建线程:  实现步骤:①、创建Callable接口的实现类,并实现call()方法,改方法将作为线程执行体,且具有返回值。  ②、创建Callable实现类的实例,使用FutrueTask类进行包装Callable对象,FutureTask对象封装了Callable对象的 call()方法的返回值  ③、使用FutureTask对象作为Thread对象启动新线程。  ④、调用FutureTask对象的get()方法获取子线程执行结束后的返回值。
java创建线程的三种方式及其对比  一: Java中创建线程主要有三种方式:  1、继承Thread类创建线程类  (1)定义Thread类的子类,并重写该类的run方法,该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。  (2)创建Thread子类的实例,即创建了线程对象。  (3)调用线程对象的start()方法来启动该线程。
package com.thread;  publicclassFirstThreadTestextendsThread{  inti =0;  //重写run方法,run方法的方法体就是现场执行体  publicvoidrun()  {  for(;i<100;i++){  System.out.println(getName()+" "+i);  }  }  publicstaticvoidmain(String[] args)  {  for(inti =0;i<100;i++)  {  System.out.println(Thread.currentThread().getName()+" : "+i);  if(i==20)  {  newFirstThreadTest().start();  newFirstThreadTest().start();  }  }  }  }  上述代码中Thread.currentThread()方法返回当前正在执行的线程对象。GetName()方法返回调用该方法的线程的名字。
2、通过Runnable接口创建线程类  (1)定义runnable接口的实现类,并重写该接口的run()方法,该run()方法的方法体同样是该线程的线程执行体。  (2)创建 Runnable实现类的实例,并依此实例作为Thread的target来创建Thread对象,该Thread对象才是真正的线程对象。  (3)调用线程对象的start()方法来启动该线程。
java创建线程的三种方式及其对照  Java中创建线程主要有三种方式:  一、继承Thread类创建线程类  (1)定义Thread类的子类。并重写该类的run方法,该run方法的方法体就代表了线程要完毕的任务。因此把run()方法称为运行体。  (2)创建Thread子类的实例,即创建了线程对象。  (3)调用线程对象的start()方法来启动该线程。  package com.thread; public class FirstThreadTest extends Thread{ int i = 0; //重写run方法。
run方法的方法体就是现场运行体 public void run() { for(;i<100;i++){ System.out.println(getName()+" "+i); } } public static void main(String[] args) { for(int i = 0;i< 100;i++) { System.out.println(Thread.currentThread().getName()+" : "+i); if(i==20) { new FirstThreadTest().start(); new FirstThreadTest().start(); } } } }  上述代码中Thread.currentThread()方法返回当前正在运行的线程对象。GetName()方法返回调用该方法的线程的名字。  二、通过Runnable接口创建线程类  (1)定义runnable接口的实现类,并重写该接口的run()方法。该run()方法的方法体相同是该线程的线程运行体。
(2)创建 Runnable实现类的实例,并依此实例作为Thread的target来创建Thread对象。该Thread对象才是真正的线程对象。  (3)调用线程对象的start()方法来启动该线程。
而且有返回值。  (2)创建Callable实现类的实例。使用FutureTask类来包装Callable对象,该FutureTask对象封装了该Callable对象的call()方法的返回值。  (3)使用FutureTask对象作为Thread对象的target创建并启动新线程。
线程创建的四种方式  java中创建线程的四种方法以及区别  Java使用Thread类代表线程,所有的线程对象都必须是Thread类或其子类的实例。Java可以用四种方式来创建线程,如下所示:  1)继承Thread类创建线程  2)实现Runnable接口创建线程  3)使用Callable和Future创建线程  4)使用线程池例如用Executor框架  下面让我们分别来看看这四种创建线程的方法。  一、继承Thread类创建线程  通过继承Thread类来创建并启动多线程的一般步骤如下  1】d定义Thread类的子类,并重写该类的run()方法,该方法的方法体就是线程需要完成的任务,run()方法也称为线程执行体。
*tips: 中国居民每日推荐摄入营养所得占比数据  在所有市售的佐餐类调味品中,老干妈是不是最火的?提及老干妈,无人不知,无人不爱。  但您有没有想过自己做一道美味的肉酱来佐餐呢?  今天给大家分享一款我常常做的肉酱:香菇肉酱。  香菇,世界第二大食用菌,能防衰抗癌,增强人体抵抗力。其香气沁脾,味道鲜美,素有“菇中之王”、“蘑菇皇后”、“蔬菜之冠”的美称。营养位列草菇、平菇之上,而且还有“植物皇后”之誉,为山珍之一。  香菇、瘦肉、甜面酱,十几分钟的时间就好。拌面、拌饭、佐以饼或馒头都可,甚至可以用来炒青菜,它的用途极广。可以一次多做些,放冰箱保存,一周内食完。  更重要的是,自己做,料更足,更放心。   在所有市售的佐餐类调味品中,老干妈是不是最火的?提及老干妈,无人不知,无人不爱。 但您有没有想过自己做一道美味的肉酱来佐餐呢? 今天给大家分享一款我常常做的肉酱:香菇肉酱。 香菇,世界第二大食用菌,能防衰抗癌,增强人体抵抗力。其香气沁脾,味道鲜美,素有“菇中之王”、“蘑菇皇后”、“蔬菜之冠”的美称。
营养位列草菇、平菇之上,而且还有“植物皇后”之誉,为山珍之一。 香菇、瘦肉、甜面酱,十几分钟的时间就好。拌面、拌饭、佐以饼或馒头都可,甚至可以用来炒青菜,它的用途极广。可以一次多做些,放冰箱保存,一周内食完。 更重要的是,自己做,料更足,更放心。   展开全部辅料  香菇洗净、肉洗净备用。我用的是新鲜香菇,现在一年四季都有新鲜香菇,很方便;我选的是瘦肉,如果您不排斥肥肉,那么选择五花肉或是带肥肉的会更香  香菇切粒,肉切小粒,姜切末,蒜切粒  由于我用的是瘦肉,所以我用了黄酒、淀粉和一点点油把它腌制了10分钟左右。这样处理既去腥肉又会很嫩滑,炒出来不会发柴发硬。如果您用的肉有肥有瘦,那么此步可以省略  热锅温油,油要多一些,放入腌好的肉粒翻炒至变色。如果您选的肥肉,这一步就要小火把肥油煸炒出来。如果吃辣,可以加辣酱进来  加入姜末和蒜粒  加入香菇粒,改大火,翻炒1分钟左右。经验表明,香菇过油炒一下会更香  改小火,把酱与油炒匀  三五分钟就好,至酱与所有材料融合。
大家好 ,我是“小猫爱厨房”的小猫,很长时间没有吃过“香菇肉酱”了。由于“疫情”的原因,所以对于吃的没什么要求,反正家中有什么就吃什么,市场上菜的品种也比较少,不是自己想吃什么就有的。这不孩子这几天都一个劲的叨叨,自己想吃“香菇肉酱”拌的面条,由于家里面有香菇,没办法今天上市场上去,一看还真有卖香菇的,只不过价钱有点贵,最后还是下狠心买了半斤回来,做一次“香菇肉酱”还是够了。说起“香菇肉酱”很多人都吃过,但是大多都是超市买的成品,味道虽说非常鲜美,最重要的就是担心安全,有时候会觉得不干净,吃着也不太放心。而且感觉还没有自己做的好吃,而且自己想什么口味自己就做什么口味,非常随便。主要是我家孩子特别爱吃我做的“香菇肉酱”,特别适合自己口味,而且味道也不比卖的差。大家要是喜欢的话,可以学着自己做,学会了做给孩子吃比买的吃着放心。话有点多了,下面还是来看看我的做法。
【制作主料】:猪肉200克(肥肉50克、瘦肉150克)、香菇250克、熟花生米50克、洋葱半个【制作调料】:生姜半块、大葱一节、大蒜3瓣、豆瓣酱20克、黄豆酱30克、老抽2克、鸡精3克、十三香2克、白糖2克、香醋3克、料酒5克、水淀粉20克——制作方法和步骤——【步骤一】:我们把肥肉切成丁(有肥肉做出来的酱味道更香),然后把瘦肉先切一下,用刀剁成肉末备用。但是要注意不要把肉末剁得太细,太细做出来的肉酱口感不是很好。其实有五花肉最好,因为五花肉肥瘦都有,做出来香而不腻。【步骤二】:我们把新鲜的香菇清洗一下,放入盐水中泡10分钟,这样可以把香菇的残余的农药和杂质泡掉,然后清洗干净后把香菇先切片改刀切丝最后切丁;然后把洋葱也切成丁,葱姜蒜都切成末分别装入盘子中备用。【步骤三】:我们把炒熟的花生米去皮,然后用擀面杖捣碎成小粒备用。【步骤四】:将所有食材备齐后,然后把锅烧热然后放入少许油,把肥肉粒倒里边,小火慢慢的把油炒出来,但是不要把油炒得太干,倒入瘦肉末大火翻炒至熟,把葱姜蒜末 放里边开小火慢慢炒香。
【步骤五】:葱姜蒜炒出香味后我们把豆瓣酱20克、黄豆酱30克放入锅中炒出酱香味道,这一步很重要,一定要把酱香味炒出来,要不把香味炒出来的话,我们做出来的酱就不香了。【步骤六】:酱香味炒出来后,把香菇丁倒里边把香菇水汽炒出来,把香菇炒软断生,然后放入一碗水,水的多少以和香菇平齐就可以了(放入的水可以多点,但是不要少了,少了炖的时间短,肉酱味道不够香)我们开始调味,依次放入料酒5克、老抽2克、鸡精3克、十三香2克、白糖2克、香醋3克然后大火烧开,开小火炖8分钟左右,中间我们要不停地用勺子搅动,防止糊锅底。【步骤七】:差不多炖了8分钟后,我们把洋葱倒里边再炖2分钟,把洋葱的味道炖入肉酱里面,然后我们倒入淀粉水大火勾芡收浓酱汁【步骤八】:酱汁收浓后,我们把花生碎倒里边,搅拌均匀后,然就关火装入盘大碗中放凉如果吃不完的话,放入冰箱中可以保存一个礼拜,随吃随取。
【步骤九】:我们锅中放烧开水,然后下入面条煮熟,捞出来,放一勺做好的“香菇肉酱”撒点香菜上桌开饭啰!【产品图】:这是我做的香菇肉酱拌面,咸香味足,香而不腻,太香了!——技术总结和注意事项——以上就是我和大家分享的香菇肉酱的做法,总体来说色泽鲜亮,咸香味浓郁,香而不腻。我们平常用来拌饭或者拌面吃,都不用吃其他菜,非常好吃。同时自己做的香菇肉酱,干净卫生无添加,吃得放心,要是吃不完的话,可以放入冰箱中保存,一般一个星期都不会坏的。看上去做这道“香菇肉酱”非常简单,但是要想真正的好吃,我们要注意几个要点。(1)我们做这个酱用猪肉的话要用肥瘦相间的肉,最好是五花肉,这样熬制出来的“香菇肉酱”香而不腻。如果我们用牛肉的话,要选用比较嫩的牛里脊。牛肉做香菇酱煮的时间要久些才能肉烂,猪肉肉比较容易煮烂,而且做出来肉酱香而不腻,我是比较喜欢用五花肉做香菇肉酱的。(2)我们熬制的时候,水要放够(一般水的多少和香菇平齐就可以),因为熬制的时间稍微要久一点,熬制出来味道会更浓郁,但并不是越久越好,一般8-10分钟就可以。
我们要多放油,因为油多熬制出来香菇酱放凉后就不会太干,放冰箱储藏时间更久。香菇酱油漫过肉酱可以隔绝空气,保存时间更长一点。辣椒酱,腐乳什么的都是用这个方法长久保存的。(3)我用的是新鲜的香菇做的,其实用干香菇味道更好。干香菇需要提前泡水,然后切香菇丁控干水分。干香菇经过泡发,炒制再熬制味道更鲜美,不过用鲜香菇成本低更划算一些。(4)我们做“香菇肉酱”要放点白糖,白糖不仅是增加甜味,还可以提鲜润色。同时要放点香醋,香醋在这里作用去腥解油腻,增加鲜味和香味,加少量的香醋,熬制出来的香菇肉酱是没有酸味的,反而鲜香味浓郁,香而不腻。结语:我做的香菇肉酱都是常见的食材调料,没有添加剂,味道很赞。做好了放冰箱冷藏,可以吃一周。香菇吃不完可以做香菇肉酱,肉吃腻了换个口味做肉酱吃。以上内容是我和大家分享的“香菇肉酱”的做法,希望对大家有所帮助 今天就和大家分享到这儿。
香菇肉酱，自己在家做起来 By 笑语流年 用料 干香菇 30朵前腿肉馅 300克洋葱 半个生姜 1块大蒜 半头豆瓣酱 2勺黄豆酱 2勺辣椒粉 3勺料酒 2勺生抽 2勺老抽 1勺蚝油 1勺胡椒粉 2勺十三香 3勺白糖 2勺盐 适量 做法步骤 1、干香菇提前泡发好，清洗干净，切成小丁。 2、前腿肉馅中加料酒，生抽，胡椒粉，盐腌制10分钟。 3、大蒜切碎。 4、生姜切成末。 5、洋葱切碎。 6、做香菇肉酱所用的食材已备好。 7、锅里多倒些油，油温五成热，下入肉馅炒2分钟，加入1勺料酒去腥，煸炒出里面的水份。 8、然后下入洋葱碎，姜末，蒜末炒出香味。 9、加入2勺豆瓣酱，2勺黄豆酱，继续煸炒。 10、再加入3勺辣椒粉（不喜辣的，可以不加） 11、下入香菇小火翻炒5分钟，炒干香菇里面的水份，这样容易保存。 12、然后加生抽，蚝油，老抽，胡椒粉，十三香，白糖，适量盐调味，继续炒1分钟，让香菇肉酱入味。 13、出锅，盛入大碗里。 14、是不是看着很诱人？用它夹馍，拌饭，炒菜都不错。 15、晾凉后放冰箱里冷藏。
香菇肉酱 香菇肉酱是一道酱品，主料有五花肉、猪皮、香菇，辅料有盐、生姜、老抽等。香菇肉酱，菜肴名称，取名独特，色感口感俱佳，深受当地民众喜爱。 食材 主料 猪肉肥瘦500克干10朵 调料 盐1茶匙，料酒1勺，生抽2勺，老抽1勺，甜面酱2勺，白糖2勺 做法 1.猪肉切成豆子大小的粒，肥瘦肉分开；香菇以冷水泡软后，也切成豆子大小的粒，泡发香菇的水不要倒掉。 2.把切出的肥肉粒放入锅中，以小火慢慢烘热，把肥油煸出。 3.然后把瘦肉粒放入锅中翻炒变色。 4.烹入料酒1勺，再倒入生抽酱油，并把泡发香菇的水也澄去杂质倒入锅中，如果水不能完全没过肉约1~2厘米，可添加适量清水，盖上锅盖，以微火慢炖约15分钟，中间需翻翻锅，以免粘锅。 5.把香菇丁倒入锅中，调入老抽酱油上色、加入甜面酱炒香，如果需要加适量盐调一下咸淡，继续以小火煮10分钟，然后放入糖大火收汁即可。做成香菇肉酱可以直接拌饭、拌面或者蘸食蔬菜，也可以作为调料烹饪其他食材。
教你在家做香菇肉酱，做法简单，香味浓郁，拌面夹馍都好吃 导读：教你在家做香菇肉酱，做法简单，香味浓郁，拌面夹馍都好吃 说起香菇肉酱，相信大家都挺熟悉的，这是生活中常见的一种酱，香菇肉酱吃起来又香又入味，不管是拌面、拌饭、还是夹馍，都挺开胃下饭的，其实香菇肉酱的吃法有很多，那么你们吃的香菇肉酱，是自己在家做的，还是在超市买的？在超市买一瓶酱，就得10块钱左右，里面的量很少，而且里面放很多的添加剂，给家人吃起来一点都不健康！今天我给大家带来家庭版香菇肉酱的做法，自己在家做的里面放的肉多，而且味道也香，比买的还便宜，教你在家做香菇肉酱，做法简单，香味浓郁，拌面夹馍都好吃！ 春天，家人最爱吃香菇肉酱，上锅一炒，酱香味浓郁，全家都爱吃！自己在家做的香菇肉酱，里面不放各种的香料，吃起来又香又下饭，而且自己做的可以放很多的肉，这样吃起来会更过瘾！自从我学会在家做香菇肉酱后，我家一周做一次，一次做上一碗，足够家人吃一周的，下面我就把香菇肉酱最详细的做法说一下，抓紧看看步骤学习一下吧！
准备一块鸡胸肉，先把表面清洗干净，再把香菇洗干净，把这两种食材表面的水分都控干，然后都切成小丁，把花生米200克，放在烤盘中，上下火180度烤10分钟，时间到取出来，先晾一会，再把外皮都搓掉，把花生米放在保鲜袋中，用擀面杖擀几下，擀成颗粒状就可以，再把香菜切成段，洋葱切成片，生姜切成片，大蒜去皮直接拍扁，再准备点香叶、桂皮、八角备用。 下面在锅里多倒点油，把香菜、洋葱、姜片、大蒜、香叶、桂皮和八角放进去炸一下，炸出香味，食材变得焦黄捞出来。再把鸡肉丁倒在锅里炸，下锅之后快速搅散，把上面的水分都炸干，再把鸡肉丁捞出来，再把香菇放进去炸一下，把香菇里的水分炸干，炸的焦黄，再加上2勺豆瓣酱炒出红油，再加上鸡肉丁、黄豆酱搅拌均匀，炒到锅里由大泡变小泡时，加上适量的白芝麻和花生碎搅拌均匀，这样就可以出锅了，然后自然晾凉，放在干净的密封罐中储存即可。 【需要注意的地方】 第一：先把鸡胸肉和香菇都清洗干净，把表面的水分都控干，再切成小丁，只要是上面没有水分，这样放在锅里翻炒的时候，里面的油不会溅出来。
我们家口味稍重,基本每日三餐都要有酱陪着,早上喝粥就着酱,中午拌饭就着酱,晚上吃面条拌着酱。但是长久以来,这酱都是在外超市买,不仅油多,关键是营养跟不上,所以我下定决心自己做酱。最想尝试的就是香菇肉酱,但是做出来的酱要么特别咸,要么食材不入味。今天老厨师教您做,熬香菇酱最关键的是放不放酱油,有人认为放酱油才能入味上色,今天跟小编一起学习,学会再也不愁没胃口。
原材料就是香菇和肉丁,肉丁依据个人喜好,我切的块比较大,这样嚼起来有口感,快来一起感受一下,烹饪过程中就开始散发香气的香菇肉酱吧!香菇肉酱By 神小仙配料:猪肉 适量、豆腐干(香干) 适量、香菇 适量、葱姜 少量、甜面酱 1袋、生抽 少量、白糖 适量烹饪步骤:1.我不喜欢碎的找不到肉,哈哈,所以我的做法是切丁,配料选择自己喜欢的,我喜欢豆制品选的香干,根据自己喜好和习惯就好!!! 猪肉切丁,也可以绞成肉馅,香干切丁,香菇泡好切好2.葱姜末适量!放不放随你开心喽!我还加了点花椒3.温锅倒油葱姜爆香4.放肉,油煎一会,把油给煎出来5.然后依次放香干和香菇煸炸,放生抽提鲜6.甜面酱和水混合搅拌开,加白糖一起7.倒香菇肉馅里小火焖8.鸡精和盐适量,大约十五分钟吧!汤汁和肉酱充分融合变得浓稠就好啦9.装盘10.汤汁也倒里边,充分入味～凉了之后放冰箱,随时吃随时取哦烹饪小贴士:1、香菇是具有高蛋白、低脂肪、多糖、多种氨基酸和多种维生素的菌类食物,常吃可以提高机体免疫功能。
肉丁香菇炸酱，简单易做，酱香浓郁 肉丁香菇炸酱 By 筠旸JY 北方人就是喜欢炸酱面，简单易做，酱香浓郁，搭配青菜，蒜瓣，咂嘴嘬面，回味无穷啊！ 原料：甜面酱、猪肉、干香菇、葱、八角、料酒、盐、玉米油、生抽、白糖、姜末。 做法步骤： 第1步、食材准备就绪。 第2步、肥瘦相间的肉一块儿。 第3步、切成小丁。 第4步、干香菇温水泡发。 第5步、洗净去蒂。 第6步、也切成小丁。 第7步、葱姜末备用。 第8步、热锅凉油放入八角爆香。 第9步、放入肉丁煸炒至变色，盛出备用。 第10步、底油小火🔥放入葱姜末爆香。 第11步、挤入适量甜面酱。 第12步、中小火🔥，用铲子搅拌均匀至冒泡了。 第13步、放入煸好的肉丁。 第14步、放入香菇丁，翻炒均匀。 第15步、加一点点白糖调味，一小勺盐调味。 第16步、倒入一小瓶盖的料酒。 第17步、根据酱的稀稠看看是否需要加一点生抽，因为甜面酱也有不同的品种。 第18步、中火咕嘟咕嘟，千万不要糊锅，搅拌均匀即可关火啦！ 第19步、成品图！ 第20步、成品图！ 第21步、成品图！ 来自 美食天下 筠旸JY 的作品。
香菇炸酱  by 热爱红烧肉 0 收藏 15030 浏览  卡路里  碳水化合物  蛋白质  卡路里  蛋白质  24.2%  *tips: 中国居民每日推荐摄入营养所得占比数据  炸  家常味  <60分钟  较低热量  初级入门  我家最爱吃炸酱了,拌面条,蘸黄瓜蔬菜,夹馒头都爱吃,尤其他吃米饭恨不能弄一勺子,我隔不时就要做一次。今天我用香菇跟猪肉一起做的味道不错,买个香菇酱里面根本没肉还那么贵,切,我自己做,多多放肉。
面条是一种非常古老的食物,它起源于中国,有着源远流长的历史。中国的面食文化可谓是博大精深,种类繁多。有资深美食专家将中国的面食分成了五个大类,分别是是山西的刀削面,河南的烩面,四川的担担面,北京的炸酱面和武汉的热干面。这种分类方法对不对咱们另说,对于一枚吃货来说,“好吃”是最重要的。想要吃到真正好吃的面食,得走到当地去,感受当地的风土人情,品尝当地的味道。 对于大部分来说,为了一碗面跑十万八千里貌似也不太现实,于是就有了现在方便食品的盛行。热干面、炸酱面都有了方便包装,加上电商和物流,一切就都不是问题了。 在家做炸酱面需要复杂的熬酱过程,往往调的酱味道还差强人意,现在有了方便包装的炸酱面,一切就都简单多了。这碗面色泽诱人,酱香浓郁,做法简单,五分钟就能完成,百吃不厌,营养又美味,比外面卖的还好吃呢。  By 飘零星 【豆果美食官方认证达人】  炸酱面 1包猪里脊肉 1块香菇3朵黄瓜1根生姜1块大蒜3瓣小葱1颗  1、准备好所有的食材。炸酱面用的是方便包装的面饼,里面带有炸酱料包和蔬菜包。