Java多线程核心技术-CSDN博客

本文链接：https://blog.csdn.net/wuxidemo/article/details/52713944

1. 继承Thread类

代码示例

public class Test {

public static void main(String[] args) {
MyThread myThread = new MyThread();
myThread.start();
System.out.println("main exit");

}
}

class MyThread extends Thread {

@Override
public void run() {
// TODO Auto-generated method stub
super.run();
System.out.println("MyThread");
}

}

打印结果为：

main exit
MyThread

说明线程启动顺序与调用次序无关。

2. 实现Runnable接口

示例代码:

public class Test {

public static void main(String[] args) {
MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
thread.start();
System.out.println("main exit");
}
}

class MyRunnable implements Runnable {

@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("MyRunnable");
}

}

打印结果：

main exit
MyRunnable

同样说明线程启动顺序与调用次序无关。

3.多线程数据安全

示例代码如下：

public class Test {

public static void main(String[] args) {

MyThread myThread = new MyThread();
Thread a = new Thread(myThread,"A");
Thread b = new Thread(myThread,"B");
Thread c = new Thread(myThread,"C");
Thread d = new Thread(myThread,"E");
Thread e = new Thread(myThread,"E");
a.start();
b.start();
c.start();
d.start();
e.start();
}
}

class MyThread extends Thread {
private int count=5;

@Override
public void run() {
// TODO Auto-generated method stub
super.run();
count--;
System.out.println("由" + this.currentThread().getName() + "计算 count =" + count);
}
}

打印结果为:

由A计算 count =3
由E计算 count =1
由C计算 count =2
由B计算 count =3
由E计算 count =0

再运行一次结果为:

由A计算 count =3
由C计算 count =0
由E计算 count =0
由B计算 count =3
由E计算 count =2

分析结果：5个线程都访问count变量，导致数据共享出现不安全，及线程安全问题。

修改代码如下解决问题:

class MyThread extends Thread {
private int count=5;

@Override
synchronizedpublic void run() {
// TODO Auto-generated method stub
super.run();
count--;
System.out.println("由" + this.currentThread().getName() + "计算 count =" + count);
}
}

运行结果如下:

由A计算 count =4
由C计算 count =3
由E计算 count =2
由B计算 count =1
由E计算 count =0

通过在run方法前添加synchronized关键字，使多个线程在执行run方法时，以排队的形式进行处理。

当一个线程调用run方法前，先判断run方法有没有被上锁，如果上锁，说明有其它线程在调用run方法（count在被使用），必须等其它线程对run方法调用结束后才可以执行自己的run调用。

这样也实现了排队调用run方法的目的。

synchronized可以在任意对象及方法上加锁，而加锁的代码称为“互斥区”或“临界区”。

4. currentThread()方法， start（），run（）方法的区别

currentThread()方法返回当前调用现成的信息。

start（）方法会重新开启一个新线程

run（）方法还在main线程里，不会先开线程

实例代码如下:

public class Test {

public static void main(String[] args) {

MyThread myThread = new MyThread();
myThread.start();
}
}

class MyThread extends Thread {

public MyThread(){
System.out.println("构造方法打印: " + Thread.currentThread().getName());
}

@Override
synchronized public void run() {
// TODO Auto-generated method stub
System.out.println("run方法打印: " + Thread.currentThread().getName());
}
}

运行结果：

构造方法打印: main
run方法打印: Thread-0

说明先运行构造函数，而且是由main线程调用的，run方法是被Thread-0调用的，run方法是start自动调用的

修改代码如下:

public class Test {

public static void main(String[] args) {

MyThread myThread = new MyThread();
//myThread.start();
myThread.run();
}
}

运行结果:

构造方法打印: main
run方法打印: main

说明run方法没有新建立线程，还是由main线程调用。

5. isAlive() getId() sleep(),interrupt()方法

isAlive判断当前线程是否处于活动状态。包括正在运行或者准备开始运行的状态，返回true；

getId获取当前线程唯一标识。

sleep方法的作用是在指定的毫秒数内让当前“正在执行的线程”休眠，即暂停执行。（this.currentThread()返回的线程）

interrupt方法仅在当前线程设置了一个停止标记，并没有立刻停止线程运行。

一般停止线程实例代码如下:

public class Test {

public static void main(String[] args) {

MyThread myThread = new MyThread();
myThread.start();
try {
Thread.sleep(2000);
myThread.interrupt();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

public void run() {
try{
for(int i=0;i<1000000;i++){
if(this.isInterrupted()){
System.out.println("已经是停止状态了");
throw new InterruptedException();
}
System.out.println(i);
}
}catch(InterruptedException e){
System.out.println("捕捉到InterruptedException");
e.printStackTrace();
}

}: