thread类,Java中Runnable和Thread的区别是什么？
thread类,Java中Runnable和Thread的区别是什么？详细介绍
本文目录一览： thread类的方法是什么？
start()，run() 都是Thread 类里的静态方法。操作方法如下：
1、创建一个JAVA工程。
2、新建一个ThreadTest类并创建一个attack方法。
3、在main方法中new一个线程并在run方法中执行attack()方法。
4、运行main方法，控制台只有一个线程说明run()方法只是Thread的一个普通方法调用。
5、使用start()。
6、控制台打印两个线程，说明调用start()方法会创建一个新的子线程并启动。
Java中Runnable和Thread的区别是什么？
在java中可有两种方式实现多线程，一种是继承Thread类，一种是实现Runnable接口；
Thread类是在java.lang包中定义的。一个类只要继承了Thread类同时覆写了本类中的run()方法就可以实现多线程操作了，但是一个类只能继承一个父类，这是此方法的局限。
Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言。Java 技术具有卓越的通用性、高效性、平台移植性和安全性，广泛应用于PC、数据中心、游戏控制台、科学超级计算机、移动电话和互联网，同时拥有全球最大的开发者专业社群。
Java由四方面组成：
Java编程语言，即语法。
Java文件格式，即各种文件夹、文件的后缀。
Java虚拟机(JVM)，即处理*.class文件的解释器。
Java应用程序接口(Java API)。
JAVA的Thread类的构造方法
Java的线程是通过java.lang.Thread类来实现的
构造方法：
Thread()
Thread(Runnable?0?2target)
参数：target 称为被创建线程的目标对象。创建目标对象target的类负责实现 Runnable接口，给出该接口中run()方法的方法体。
利用构造方法创建新线程对象后，进入线程的新建状态。
thread类的方法有哪些
SubThread是Thread的子类，子类构造方法调用父类构造方法
最近整理的jdk1.8最新方法，详细具体用法下载个1.8手册看看就可以
Thread()、Thread(Runnable target)、Thread(Runnable target, String name)、Thread(String name)、Thread(ThreadGroup group, Runnable target)、Thread(ThreadGroup group, Runnable target, String name)、Thread(ThreadGroup group, Runnable target, String name, long stackSize)、Thread(ThreadGroup group, String name)、static int activeCount()、void checkAccess()、static、Thread currentThread()、static void dumpStack()、static int enumerate(Thread[] tarray)、static Map
getAllStackTraces()、ClassLoader getContextClassLoader()、static Thread.UncaughtExceptionHandler getDefaultUncaughtExceptionHandler()、long getId()、String getName()、int getPriority()、StackTraceElement[] getStackTrace()、Thread.State、getState()、ThreadGroup getThreadGroup()、Thread.UncaughtExceptionHandlergetUncaughtExceptionHandler()、void interrupt()、static boolean interrupted()、boolean isAlive()、boolean isDaemon()、boolean isInterrupted()、void join()、void join(long millis)、void join(long millis, int nanos)、void run()、void setContextClassLoader(ClassLoader cl)、void setDaemon(boolean on)、static void setDefaultUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh)、void setName(String name)、void setPriority(int newPriority)、void setUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh)、static void sleep(long millis)、static void sleep(long millis, int nanos)、void start()、String toString()、static void yield()
C++中使用Thread类需要包含什么头文件
看操作系统，标准C++没有现成的概念，但是c里面提供了这些线程的api
windows和linux略有不同
#include
包含头文件 #include
1、std::thread 的使用非常放便和强大，该类几乎可以把任何函数作为线程主函数。2、用法： 首先包含头文件 #include
定义线程主函数： 根据不同的需要，线程的主函数可以是普通函数、函数对象、lambda表达式或者类成员函数。 建立std::thread对象，并把线程要运行的函数（线程主函数）以及相应的函数参数通过构造函数传递给该对象， 构造函数通常会海纳百川。例程：
#include
#include
class ThreadMain {public: void operator()() { run(); } void run() { std::cout << "Hello, C++11 thread\n"; }};void generalFunc(int data) { std::cout << "Hello, C++11 thread\n";}int main() { ThreadMain tm; std::thread t1(generalFunc, 1); /*传递普通函数指针和参数0给thread对象t1*/ std::thread t2(&ThreadMain::run, &tm); /*将成员函数传递给thread对象t2， 并且传递调用该函数的对象的指针&tm*/ std::thread t3(tm); /*传递一个函数对象给t3*/ std::thread t4([]() { std::cout << "Hello, C++11 thread\n"; }); /*传递lambda表达式给thread对象t4*/ /* 调用join函数等待线程终止，并回收线程所占资源*/ t1.join(); t2.join(); t3.join(); t4.join();}
如何创建和启动一个线程
方式1：继承Thread类
步骤:
1):定义一个类A继承于Java.lang.Thread类.
2):在A类中覆盖Thread类中的run方法.
3):我们在run方法中编写需要执行的操作：run方法里的代码,线程执行体.
4):在main方法(线程)中,创建线程对象,并启动线程.
(1)创建线程类对象:
A类 a = new A类();
(2)调用线程对象的start方法:
a.start();//启动一个线程
注意:千万不要调用run方法,如果调用run方法好比是对象调用方法,依然还是只有一个线程,并没有开启新的线程.
线程只能启动一次！
创建启动线程实例：
//1):定义一个类A继承于java.lang.Thread类. class MusicThread extends Thread{ //2):在A类中覆盖Thread类中的run方法. public void run() { //3):在run方法中编写需要执行的操作 for(int i = 0; i < 50; i ++){ System.out.println("播放音乐"+i); } } } public class ExtendsThreadDemo { public static void main(String[] args) { for(int j = 0; j < 50; j ++){ System.out.println("运行游戏"+j); if(j == 10){ //4):在main方法(线程)中,创建线程对象,并启动线程. MusicThread music = new MusicThread(); music.start(); } } } }方式2：实现Runnable接口
步骤:
1):定义一个类A实现于java.lang.Runnable接口,注意A类不是线程类.
2):在A类中覆盖Runnable接口中的run方法.
3):我们在run方法中编写需要执行的操作：run方法里的,线程执行体.
4):在main方法(线程)中,创建线程对象,并启动线程.
(1)创建线程类对象:
Thread t = new Thread(new A());
(2)调用线程对象的start方法:
t.start();
//1):定义一个类A实现于java.lang.Runnable接口,注意A类不是线程类. class MusicImplements implements Runnable{ //2):在A类中覆盖Runnable接口中的run方法. public void run() { //3):在run方法中编写需要执行的操作 for(int i = 0; i < 50; i ++){ System.out.println("播放音乐"+i); } } } public class ImplementsRunnableDemo { public static void main(String[] args) { for(int j = 0; j < 50; j ++){ System.out.println("运行游戏"+j); if(j == 10){ //4):在main方法(线程)中,创建线程对象,并启动线程 MusicImplements mi = new MusicImplements(); Thread t = new Thread(mi); t.start(); } } } }分析继承方式和实现方式的区别:
继承方式: 1):从设计上分析，Java中类是单继承的,如果继承了Thread了,该类就不能再有其他的直接父类了. 2):从操作上分析,继承方式更简单,获取线程名字也简单.(操作上,更简单) 3):从多线程共享同一个资源上分析,继承方式不能做到.实现方式: 1):从设计上分析，Java中类可以多实现接口,此时该类还可以继承其他类,并且还可以实现其他接口，设计更为合理. 2):从操作上分析,实现方式稍微复杂点,获取线程名字也比较复杂,得使用Thread.currentThread()来获取当前线程的引用.
3):从多线程共享同一个资源上分析,实现方式可以做到(是否共享同一个资源).
补充：实现方式获取线程名字：
String name = Thread.currentThread().getName();
启动一个新的线程很简单，直接调用线程类的start()方法就可以了。但是必须是线程类，就是必须实现了Runnable接口的类，当然也可以是继承Thread类因为Thread也实现了Runnable接口。
Runnable接口有一个run()方法，java虚拟机会自己执行这个方法。你只需要重写这个方法就可以了。但是你不能自己调用这个方法，例如像这样：
Thread thread = new StartThread();
thread.run();
而是应该像这样：
Thread thread = new StartThread();
thread.start();
你可以试一试下面的程序用thread.run();和thread.start();有什么不同。
public class StartThread extends Thread
{
@Override
public void run()
{
String name = Thread.currentThread().getName();
int i = 0;
for(i = 0;i<10;i++)
{
System.out.println(name+": "+i);
}
try
{
Thread.sleep(1000);
} catch (InterruptedException e)
{
e.printStackTrace();
}
for( ;i<20;i++)
{
System.out.println(name+": "+i);
}
}
public static void main(String[] args)
{
Thread thread = new StartThread();
thread.start();
// thread.run();
try
{
Thread.sleep(200);
} catch (InterruptedException e)
{
e.printStackTrace();
}
String name = Thread.currentThread().getName();
for(int i = 0;i<10;i++)
{
System.out.println(name+": "+i);
}
}
}
1、设计一个线程，产生三个线程对象，设置三个线程的休眠时间，10s，20s，30s。主要采用Thread类，Runable接口。
2、thread类是java.lang包中定义的，一个类只要继承Thread类，此类就是多线程操作类使用Threa类实现。
3、测试运行结果。
4、使用runnable接口实现，类中没有线程名称字段，所以建立一个name属性保存线程名称。
5、使用runnable接口，new Thread().start() 执行。
关于Thread和Runnable的关系,以下说法哪一个是正确的？
四个选项都有问题。
正确的讲法应该是：
Thread类实现了Runnable接口。
非要选一个就选B吧。
看APi文档，Thread的构造方法有一个是：Thread(Runnable target)； 继承Runnable的类就是一个线程类；
Java有两种方式实现多线程,第一个是继承Thread类,第二个是实现Runnable接口.他们之间的联系:1、Thread类实现了Runable接口
正好整理过一些笔记.Thread和Runnable:多线程AsyncTask和Handler的简单用法:【Android笔记】多线程与 UI 交互的方法
break是thread类中的方法吗
1、继承Thread类，重写run方法
??方式一、不借助匿名内部类
创建一个继承于Thread类的子类
在该子类中重写Thread类中的run方法
实例化该子类类型，用父类Thread引用重写了run方法的子类对象，向上转型
通过上述引用调用start方法，创建该线程，并将该线程（PCB参与到系统调度中，与其他线程一起进行随机调度执行）
??方式二、借助匿名内部类
借助该匿名内部类将上述三步：子类继承Thread、重写run、创建实例化对象，合并为一步
调用start方法
Thread 的常见构造方法
方法 说明
Thread() 创建线程对象
Thread(Runnable target) 使用 Runnable 对象创建线程对象
Thread(String name) 创建线程对象并命名
Thread(Runnable target,String name) 使用 Runnable 对象创建线程对象并命名
关于前两种方法，在之前的线程创建介绍中有使用到
线程创建根本上来讲有两种创建方法：
创建一个继承自 Thread 类的子类，重写 Thread 中的 run 方法，调用 start 方法
创建一个实现 Runnable 接口的类，重写 Thread 中的 run 方法。创建 Thread 实例，将自己写的实现 Runnable 接口的类的实例设置进去，调用 start 方法
构造方法三和四不过是在前面两种构造方法的基础上多添加了一个给线程对象命名的参数，方便程序员进行调试。
代码（以构造方法四为例）：
public class func7 {
public static void main(String[] args) {
Thread thread = new Thread(() ->{
while (true) {
System.out.println("This is my Thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"myThread");
//此处用 lambda 表达式代替 Runnable 实例，更加简洁，添加了一个参数指定thread线程的名字
thread.start();
while (true) {
System.out.println("my main");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
程序员可以通过 JDK 自带的jconsole工具来直观查看这里创建的线程
步骤一：
运行程序后，找到自己的 jdk 路径 -> bin ->jconsole.exe
在这里插入图片描述
步骤二：双击该 exe 文件。选择本地进程，这里罗列着 Java 进程。可以看见我们的程序 func7 ，点击它。在菜单栏选择线程一栏
在这里插入图片描述
步骤三：查看线程信息
在这里插入图片描述
左侧可以选择需要被查看的线程，可以看见主线程 main和新创建的线程 myThread ，如果没有重命名操作的话新创建的线程名就会叫 Thread-0，Thread-1 这样的名字，不方便查看。
右侧显示了该线程的被读取的那一瞬间的状态，堆栈跟踪显示的是代码具体执行的位置
Thread 类的优先级有哪五种
最高 THREAD_PRIORITY_HIGHEST 线程在高于正常优先级上两级上运行。
高于正常 THREAD_PRIORITY_ABOVE_NORMAL 线程在正常优先级上一级上运行。
正常 THREAD_PRIORITY_NORMAL 线程在进程的优先级类上正常运行。
低于正常 THREAD_PRIORITY_BELOW_NORMAL 线程在低于正常优先级下一级上运行。
最低 THREAD_PRIORITY_LOWEST 线程在低于正常优先级下两级上运行。
空闲 THREAD_PRIORITY_IDLE 对于实时优先级类线程在优先级16上运行对于其他优先级类线程在优先级1上运行。