线程:
进程是指在系统中正在运行的一个应用程序,线程是比进程更小的执行单位。
线程是程序执行的一条路径,一个进程中可以包含多条线程,多线程并发执行可以提高程序的效率。
多线程并行和多线程并发的区别:
并行是指在多核CPU下,多个任务同时运行。
并发是指在一个CPU下,多个任务轮流交替执行,每个任务执行的时间都很短,使人感觉多个任务是同时运行的。即从宏观上看,多个任务是同时进行,但从微观上看,CPU在同一时间内只能执行一个任务。
Java程序的运行原理:
Java命令会启动java虚拟机,启动JVM,等于启动了一个应用程序,也就是启动了一个进程。该进程会自动启动一个”主线程“,然后主线程去调用某个类的main方法。
jvm支持多线程:启动了主线程、垃圾回收器线程。
多线程实现方式:
1. 继承Thread类,并重写run方法
2. 实现Runnable接口
Thread类:
publicclass Thread extends Object implements Runnable,是lang包下的类,不需要导入,直接使用。
构造方法:
public Thread(Runnable target)分配新的 Thread 对象。参数target 是其 run 方法被调用的对象。
public Thread(String name)分配新的 Thread 对象。参数就是给该线程起一个名字。
主要方法:
publicvoid start():使该线程开始执行;Java 虚拟机自动调用该线程的 run 方法。一个线程类对象只能调用一次start方法,否则会出现异常(java.lang.IllegalThreadStateException)。
publicvoid run()如果该线程是使用独立的 Runnable 运行对象构造的,则调用该 Runnable 对象的 run 方法;否则,该方法不执行任何操作并返回。 Thread的子类应该重写该方法,因为Thread类中的run方法没有具体内容,run方法中写的是要执行的代码。
public final String getName()返回该线程的名称。
public final void setName(Stringname)改变线程名称,使之与参数name 相同。
public static Thread currentThread()返回对当前正在执行的线程对象的引用。静态方法,直接用类名调用。
public static void sleep(longmillis) throws InterruptedException在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)。静态方法,直接用类名调用。该方法是自动睡眠指定的时间,然后自动唤醒。
public final void setDaemon(booleanon)将该线程标记为守护线程或用户线程。该方法必须在启动线程前调用。当正在运行的线程都是守护线程时,Java 虚拟机退出。参数如果是true,就表示把该线程设置为守护线程。非守护线程终止时,守护线程也就终止了。
public final void join() throwsInterruptedException等待该线程终止。相当于插队。
public final void join(long millis) throws InterruptedException等待该线程终止的时间最长为 millis 毫秒。插队时间为传输的参数毫秒值。
public final void setPriority(int newPriority)更改线程的优先级。最小是1(MIN_PRIORITY
),最大是10(MAX_PRIORITY),如果不设置,默认优先级为5。
实现线程代码示例:
package com.thread;
public class Lianxi1 {
publicstatic void main(String[] args) {
MyThreadt = new MyThread();//创建线程的子类对象
//t.run();//直接调用run方法,就相当于普通的方法一样,所以就先执行run方法,即打印输出100000次******,执行结束后,再执行主线程中的for循环。
t.start();//开启线程,自动调用run方法,和主线程交替执行,所以输出*****和输出##交替执行,且每次运行的结果不尽相同,输出结果依赖于当前CPU资源的使用情况。
//t.start();//调用两次start方法会报异常
for(inti = 0;i<1000;i++){//主线程中的语句
System.out.println("###");
}
}
}
class MyThread extends Thread{
publicvoid run(){//将要执行的代码
for(inti = 0;i<1000;i++){
System.out.println("**************");
}
}
}
sleep方法代码示例:
new Thread(new Runnable(){
publicvoid run(){
for(inti = 0;i<20;i++){
try{
Thread.sleep(500);
}catch (InterruptedException e) {
//TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("bb");
}
}
}).start();
setDaemon()方法代码示例:
package com.thread;
public class Lianxi7 {
publicstatic void main(String[] args) {
Threadt1 = new Thread("非守护线程"){
publicvoid run(){
for(inti = 0;i<3;i++){
System.out.println("aaaaaaaaaa");
}
}
};
Threadt2 = new Thread("守护线程"){
publicvoid run(){
for(inti = 0;i<100;i++){
System.out.println(i);
}
}
};
t1.start();
t2.setDaemon(true);//将t2设置为守护线程,该方法必须在开启线程之前使用
t2.start();//非守护线程执行完毕之后,守护线程有一个缓冲时间,然后才会停止守护线程。
}
}
join方法代码示例:
public static void main(String[] args) {
finalThread t1 = new Thread(){
publicvoid run(){
for(int i = 0;i<20;i++){
System.out.println("aaaaaaaa"+i);
}
}
};
Threadt2 = new Thread(){
publicvoid run(){
for(int i = 0;i<10;i++){
if(i== 3){
try{
t1.join();//当i=3时,t1线程就插队执行,直到执行完毕,再继续执行t2线程
//t1.join(1);//当i=3时,t1线程插队执行一毫秒,一毫秒之后这两个线程再交替执行。
}catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("b"+i);
}
}
};
t1.start();
t2.start();
}
join无参方法运行结果如图:
join(long millis)方法运行结果图:
Runnable接口:
publicinterface Runnable,Runnable 接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为 run 的无参数方法。
方法:
void run():使用实现接口 Runnable 的对象创建一个线程时,启动该线程将导致在独立执行的线程中调用对象的 run 方法。
Runnable只有一个run方法,没有start方法,所以想要开启线程,需要使用Thread的一个构造方法:public Thread(Runnable target),将接口实现类对象传进去,获得一个Thread对象,然后调用Thread的start方法,开启线程。
代码示例:
packagecom.thread;
publicclass Lianxi2 {
public static void main(String[] args) {
MyRunnable m = new MyRunnable();//创建线程目标执行类对象
Thread t = new Thread(m);//使用Thread的构造方法,传入的参数是Runnable的实现类对象,然后就可以调用Thread的start方法开启线程(使用线程目标执行类对象创建线程对象)
t.start();//开启线程
for(int i = 0;i<1000;i++){
System.out.println("###");
}
}
}
classMyRunnable implements Runnable{
public void run() {
for(int i = 0;i<1000;i++){
System.out.println("**************");
}
}
}
使用匿名内部类实现多线程的两种方式:
代码示例:
通过匿名内部类创建Thread对象:
public static void main(String[] args) {
newThread(){//创建匿名内部类对象
public void run(){//重写run方法
for(int i = 0;i<1000;i++){
System.out.println("aaaaaaaaaaaaaaaa");
}
}
}.start();//开启线程(绿色阴影部分是Thread的子类对象,直接调用start对象)
}
通过匿名内部类创建Runnable实现类对象:
public static void main(String[] args) {
new Thread(new Runnable(){//使用匿名内部类创建接口实现类对象,再把它作为参数创建Thread对象
public void run() {
for(inti = 0;i<1000;i++){
System.out.println("bb");
}
}}).start();//创建好了Thread子类对象调用start方法开启线程
}//绿色阴影部分是接口的实现类对象,然后作为Thread构造方法的参数,创建得到Thread对象,再调用start方法开启线程。
两种实现多线程的方法的区别:
继承Thread类:创建子类对象,直接调用start方法即可开启线程并自动调用run方法。
好处:可以直接获得start方法,代码简单。
弊端:如果子类有了父类,再想使用该方法就不可以继承Thread,因为java中的继承是单继承,一个子类只能继承一个父类。
实现Runnable接口:创建一个接口的实现类对象,然后作为参数传入Thread的构造方法,得到一个Thread对象,用该对象调用Thread类的start方法,start自动调用本类中的run方法,在run方法中会判断一下runnable对象是否为空,如果不为空,那就调用接口子类对象中的run方法。否则就执行Thread子类对象的run方法(第一种多线程实现方式,继承Thread的run方法时,编译看Thread,运行看子类的run)。
好处:即使有了父类也可以实现该接口,并且可以实现多个接口。
弊端:实现类对象需要作为参数,创建一个Thread对象,使用Thread的start方法开启线程,代码复杂。
设置线程名称的方法:
1. 通过Thread有参构造方法:public Thread(String name)
2. 使用Thread的setName方法:public final void setName(Stringname)
获取线程名称的方法:
使用Thread类的getName方法,但是当使用接口来实现线程时,在实现类对象内部不能直接调用getName方法。
需要使用Thread类的静态方法currentThread来获取当前正在执行的线程对象,然后再使用getName方法,获取县城名称,如果需要设置名称,也需要获取当前线程对象然后再使用setName设置名称。
代码示例:
newThread(new Runnable(){
public void run() {
Thread.currentThread().setName("第二个线程");//获取当前正在执行的线程 System.out.println(Thread.currentThread().getName()+"bbbbbbbbbb" }
}).start();