「java开启新线程」java开启线程异步执行
本篇文章给大家谈谈java开启新线程，以及java开启线程异步执行对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。
本文目录一览：
- 1、java有几种实现线程的方式？
- 2、Java多线程支持如何才能解决接口问题
- 3、java创建线程之后，直接调用start方法和run的区别
- 4、JAVA中怎样激活线程？
- 5、java多线程有几种实现方法
- 6、Java中在线程中再开线程，可以么
java有几种实现线程的方式？
有三种：
(1)继承Thread类，重写run函数
创建：class xx extends Thread{ public void run(){Thread.sleep(1000)//线程休眠1000毫秒，sleep使线程进入Block状态，并释放资源}}
开启线程：对象.start()//启动线程，run函数运行
(2)实现Runnable接口，重写run函数
开启线程：Thread t = new Thread(对象)//创建线程对象t.start()
(3)实现Callable接口，重写call函数
Callable是类似于Runnable的接口，实现Callable接口的类和实现Runnable的类都是可被其它线程执行的任务。
Java多线程支持如何才能解决接口问题
Java多线程支持需要我们不断的进行相关问题的解决 下面我们就来看看在接口问题上的相关问题解决方案 这样才能更好的进行不断的创新和学习 希望大家有所了解
Java多线程支持 所有实现Runnable接口的类都可被启动一个新线程 新线程会执行该实例的run()方法 当run()方法执行完毕后 线程就结束了 一旦一个线程执行完毕 这个实例就不能再重新启动 只能重新生成一个新实例 再启动一个新线程
Thread类是实现了Runnable接口的一个实例 它代表一个线程的实例 并且 启动线程的唯一方法就是通过Thread类的start()实例方法
Thread t = new Thread();
t start();
start()方法是一个native方法 它将启动一个新线程 并执行run()方法 Thread类默认的run()方法什么也不做就退出了 注意 直接调用run()方法并不会启动一个新线程 它和调用一个普通的java多线程支持方法没有什么区别
因此 有两个方法可以实现自己的线程
方法 自己的类extend Thread 并复写run()方法 就可以启动新线程并执行自己定义的run()方法 例如
public class MyThread extends Thread {
public run() {
System out println( MyThread run() );
}
}
在合适的地方启动线程 new MyThread() start();
方法 如果自己的类已经extends另一个类 就无法直接extends Thread 此时 必须实现一个Runnable接口
public class MyThread extends OtherClass implements Runnable {
public run() {
System out println( MyThread run() );
}
}
为了启动MyThread 需要首先实例化一个Thread 并传入自己的MyThread实例
MyThread myt = new MyThread();
Thread t = new Thread(myt);
t start();
事实上 当传入一个Runnable target参数给Thread后 Thread的run()方法就会调用target run() 参考JDK源代码
public void run() {
if (target != null) {
target run();
}
}
lishixinzhi/Article/program/Java/gj/201311/27571
java创建线程之后，直接调用start方法和run的区别
start与run方法的主要区别在于当程序调用start方法一个新线程将会被创建，并且在run方法中的代码将会在新线程上运行，然而在你直接调用run方法的时候，程序并不会创建新线程，run方法内部的代码将在当前线程上运行。大多数情况下调用run方法是一个bug或者变成失误。因为调用者的初衷是调用start方法去开启一个新的线程，这个错误可以被很多静态代码覆盖工具检测出来，比如与fingbugs. 如果你想要运行需要消耗大量时间的任务，你最好使用start方法，否则在你调用run方法的时候，你的主线程将会被卡住。另外一个区别在于，一但一个线程被启动，你不能重复调用该thread对象的start方法，调用已经启动线程的start方法将会报IllegalStateException异常， 而你却可以重复调用run方法。
JAVA中怎样激活线程？
得要看你当前线程处于何种状态的;
线程启动过程：
在线程的Thread对象上调用start()方法，而不是run()或者别的方法。
在调用start()方法之前：线程处于新状态中，新状态指有一个Thread对象，但还没有一个真正的线程。
在调用start()方法之后：发生了一系列复杂的事情
启动新的执行线程（具有新的调用栈）；
该线程从新状态转移到可运行状态；
当该线程获得机会执行时，其目标run()方法将运行。
注意：对Java来说，run()方法没有任何特别之处。像main()方法一样，它只是新线程知道调用的方法名称(和签名)。因此，在Runnable上或者Thread上调用run方法是合法的。但并不启动新的线程。
java多线程有几种实现方法
继承Thread类来实现多线程:
当我们自定义的类继承Thread类后，该类就为一个线程类,该类为一个独立的执行单元，线程代码必须编写在run()方法中,run方法是由Thread类定义，我们自己写的线程类必须重写run方法。
run方法中定义的代码为线程代码，但run方法不能直接调用，如果直接调用并没有开启新的线程而是将run方法交给调用的线程执行
要开启新的线程需要调用Thread类的start()方法，该方法自动开启一个新的线程并自动执行run方法中的内容
请点击输入图片描述
结果：
请点击输入图片描述
*java多线程的启动顺序不一定是线程执行的顺序，各个线程之间是抢占CPU资源执行的，所有有可能出现与启动顺序不一致的情况。
CPU的调用策略：
如何使用CPU资源是由操作系统来决定的，但操作系统只能决定CPU的使用策略不能控制实际获得CPU执行权的程序。
线程执行有两种方式：
1.抢占式：
目前PC机中使用最多的一种方式，线程抢占CPU的执行权，当一个线程抢到CPU的资源后并不是一直执行到此线程执行结束，而是执行一个时间片后让出CPU资源，此时同其他线程再次抢占CPU资源获得执行权。
2.轮循式;
每个线程执行固定的时间片后让出CPU资源，以此循环执行每个线程执行相同的时间片后让出CPU资源交给下一个线程执行。
Java中在线程中再开线程，可以么
对于进程最直观的感受应该就是“windows任务管理器”中的进程管理：
（计算机原理课上的记忆已经快要模糊了，简单理解一下）：一个进程就是一个“执行中的程序”，是程序在计算机上的一次运行活动。程序要运行，系统就在内存中为该程序分配一块独立的内存空间，载入程序代码和资源进行执行。程序运行期间该内存空间不能被其他进程直接访问。系统以进程为基本单位进行系统资源的调度和分配。何为线程?线程是进程内一次具体的执行任务。程序的执行具体是通过线程来完成的，所以一个进程中至少有一个线程。回忆一下 HelloWrold 程序中main方法的执行，其实这时候，Java虚拟机会开启一个名为“main”的线程来执行程序代码。一个进程可以包含多个线程，这些线程共享数据空间和资源，但又分别拥有各自的执行堆栈和程序计数器。线程是CPU调度的基本单位。
多线程
一个进程包含了多个线程，自然就叫做多线程。拥有多个线程就可以让程序看起来可以“同时”处理多个任务，为什么是看起来呢?因为CPU也分身乏术，只能让你这个线程执行一会儿，好了你歇着，再让另一个线程执行一会儿，下次轮到你的时候你再继续执行。这里的“一会儿”实际上时间非常短，感觉上就是多个任务“同时”在执行。CPU就这样不停的切来切去…既然CPU一次也只能执行一个线程，为什么要使用多线程呢?当然是为了充分利用CPU资源。一个线程执行过程中不可能每时每刻都在占用CPU，CPU歇着的时候我们就可以让它切过来执行其他的线程。
Java中的多线程
Java中启用多线程有两种方式：①继承Thread类；②实现Runnable接口。
There are two ways to create a new thread of execution. One is to declare a class to be a subclass of Thread. This subclass should override the run method of class Thread. An instance of the subclass can then be allocated and started.The other way to create a thread is to declare a class that implements the Runnable interface. That class then implements the run method. An instance of the class can then be allocated, passed as an argument when creating Thread, and started.
继承Thread类
创建一个类，继承java.lang.Thread，并覆写Thread类的run()方法，该类的实例就可以作为一个线程对象被开启。
/**
* Dog类，继承了Thread类
* @author lt
*/
class Dog extends Thread {
/*
* 覆写run()方法，定义该线程需要执行的代码
*/
@Override
public void run() {
for (int i = 0; i 10; i++) {
System.out.println(i);
}
}
}
线程创建好了，怎么让它作为程序的一个独立的线程被执行呢?创建一个该类的实例，并调用start()方法，将开启一个线程，并执行线程类中覆写的run()方法。
public class ThreadDemo {
public static void main(String[] args) {
Dog dog = new Dog();
dog.start();
}
}
看不出什么端倪，如果我们直接调用实例的run()方法，执行效果是完全一样的，见上图。
public class ThreadDemo {
public static void main(String[] args) {
Dog dog = new Dog();
dog.run();
}
}
如果一切正常，这时候程序中应该有两个线程：一个主线程main，一个新开启的线程。run()方法中的代码究竟是哪个线程执行的呢?Java程序中，一个线程开启会被分配一个线程名：Thread-x，x从0开始。我们可以打印当前线程的线程名，来看看究竟是谁在执行代码。
class Dog extends Thread {
@Override
public void run() {
for (int i = 0; i 10; i++) {
System.out.println("当前线程：" + Thread.currentThread().getName() + "---" + i);
}
}
}
public class ThreadDemo {
public static void main(String[] args) {
System.out.println("当前线程：" + Thread.currentThread().getName());
Dog dog = new Dog();
dog.start();
}
}
可以看到，确实开启了一个新的线程：Thread-0，main()方法的线程名就叫main。
同一个实例只能调用一次start()方法开启一次，多次开启，将报java.lang.IllegalThreadStateException异常：
我们再创建一个实例，开启第三个线程：
public class ThreadDemo {
public static void main(String[] args) {
System.out.println("当前线程：" + Thread.currentThread().getName());
Dog dog = new Dog();
Dog dog2 = new Dog();
dog.start();
dog2.start();
}
}
这时候我们已经能够看到多线程的底层实现原理：CPU切换处理、交替执行的效果了。
run和start
上面我们直接调用run()方法和调用start()方法的结果一样，现在我们在打印线程名的情况下再来看看：
public class ThreadDemo {
public static void main(String[] args) {
System.out.println("当前线程：" + Thread.currentThread().getName());
Dog dog = new Dog();
Dog dog2 = new Dog();
dog.run();
dog2.run();
}
}
可以看到，这时候并没有开启新的线程，main线程直接调用执行了run()方法中的代码。所以start()方法会开启新的线程并在新的线程中执行run()方法中的代码，而run()方法不会开启线程。查看start()的源代码，该方法调用了本地方法 private native void start0();即调用的是操作系统的底层函数：
public synchronized void start() {
if (threadStatus != 0)
throw new IllegalThreadStateException();
group.add(this);
boolean started = false;
try {
start0();
started = true;
} finally {
try {
if (!started) {
group.threadStartFailed(this);
}
} catch (Throwable ignore) {
/* do nothing. If start0 threw a Throwable then
it will be passed up the call stack */
}
}
}
private native void start0();
实现Runnable接口
第二种方式，实现Runnable接口，并覆写接口中的run()方法，这是推荐的也是最常用的方式。Runnable接口定义非常简单，就只有一个抽象的run()方法。
//Runnable接口源码
public interface Runnable {
public abstract void run();
}
class Dog implements Runnable {
@Override
public void run() {
for (int i = 0; i 10; i++) {
System.out.println("当前线程：" + Thread.currentThread().getName() + "---" + i);
}
}
}
这时候的Dog类看起来跟线程什么的毫无关系，也没有了start()方法，怎么样开启一个新的线程呢?直接调用run()方法?想想也不行。这时候我们需要将一个Dog类的实例，作为Thread类的构造函数的参数传入，来创建一个Thread类的实例，并通过该Thread类的实例来调用start()方法从而开启线程。
public class ThreadDemo {
public static void main(String[] args) {
System.out.println("当前线程：" + Thread.currentThread().getName());
Dog dog = new Dog();
Thread thread = new Thread(dog);
thread.start();
}
}
这时候如果要开启第三个线程，需要创建一个新的Thread类的实例，同时传入刚才的Dog类的实例（当然也可以创建一个新的Dog实例）。这时候我们就可以看到跟继承Thread类的方式的区别：多个线程可以共享同一个Dog类的实例。
public class ThreadDemo {
public static void main(String[] args) {
System.out.println("当前线程：" + Thread.currentThread().getName());
Dog dog = new Dog();
Thread thread = new Thread(dog);
Thread thread2 = new Thread(dog);
thread.start();
thread2.start();
}
}
两种方式的比较
继承Thread类的方式有它固有的弊端，因为Java中继承的单一性，继承了Thread类就不能继承其他类了；同时也不符合继承的语义，Dog跟Thread没有直接的父子关系，继承Thread只是为了能拥有一些功能特性。而实现Runnable接口，①避免了单一继承的局限性，②同时更符合面向对象的编程方式，即将线程对象进行单独的封装，③而且实现接口的方式降低了线程对象(Dog)和线程任务(run方法中的代码)的耦合性，④如上面所述，可以使用同一个Dog类的实例来创建并开启多个线程，非常方便的实现资源的共享。实际上Thread类也是实现了Runnable接口。实际开发中多是使用实现Runnable接口的方式。
java开启新线程的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java开启线程异步执行、java开启新线程的信息别忘了在本站进行查找喔。