线程是在进程中独立运行的子任务。
什么场景使用多线程技术？
1.阻塞。一旦系统中出现了阻塞现象，则可以根据实际情况来使用多线程技术提高运行效率。
2.依赖。业务分为两个执行过程，A和B,A业务发生阻塞时，B业务不需要A业务的执行结果，这时B业务可以使用多线程技术提高运行效率。
多线程是异步的。多线程随即执行，是因为CPU将时间片（时间片是CPU分配给各个程序的时间）分给不同的线程，线程获得时间片后才能执行任务。
CPU在不同的线程上进行切换是需要耗时的，所以并不是创建的线程越多，软件运行效率就越高，相反，线程过多反而会降低软件的执行效率。
实现多线程技术的两种方式： 1.继承Thread类，2.实现Running接口。
说明 ：1.Thread 类实现了Running接口。 2.使用继承Thread类的方式创建新线程时，就不支持多继承了。
public class Thread implements Runnable
继承Thread类创建线程。
MyThread.java
package thread;
public class MyThread extends Thread {
@Override
public void run() {
super.run();
System.out.println("运行了MyThread");
}
}
MyThreadRun.java
package thread;
public class MyThreadRun {
public static void main(String[] args) {
MyThread thread = new MyThread();
thread.start();// 耗时大
System.out.println("结束");//耗时小
}
}
运行结果
实现Running接口创建线程。
MyRunning.java
package thread;
public class MyRunning implements Runnable {
@Override
public void run() {
System.out.println("运行了MyRuning");
}
}
MyRunningRun.java
package thread;
public class MyRunningRun {
public static void main(String[] args) {
Runnable runnable = new MyRunning();
Thread thread = new Thread(runnable);
thread.start();
System.out.println("运行结束");
}
}
运行结果
共享数据 ： 多个线程可以访问同一个变量。例如购票。
使用synchronized 关键字，使多个线程在执行run方法时，以排队的方式进行处理。
synchronized可以对任何对象及方法加锁，而加锁的这段代码称为“互斥区”或"临界区"。
synchronized关键字实现同步的原因是：使用了flag标记ACC_SYNCHRONIZED,当调用方法时，调用指令会检查方法的ACC_SYNCHRONIZED访问标志是否设置，如果设置了，执行线程会持有同步锁，然后执行方法，最后扎起方法完成时释放锁。
MyThread.java
package thread;
public class MyThread extends Thread {
private int count = 5; //总票数
@Override
synchronized public void run() {
super.run();
count--;
System.out.println("由 " + Thread.currentThread().getName() +" 售票， 现在剩余票count = " + count );
}
}
MyThreadRun.java
package thread;
public class MyThread extends Thread {
private int count = 5; //总票数
@Override
synchronized public void run() {
super.run();
count--;
System.out.println("由 " + Thread.currentThread().getName() +" 售票， 现在剩余票count = " + count );
}
}
运行结果 可以看到运行结果并不是按照ABCDE 进行执行的，说明执行start()的顺序不代表执行run()的顺序
非线程安全问题主要是指多个线程对同一个对象中的同一个实例变量进行操作时会出现值被更改、值不同步的情况。进而影响程序执行流程。
run() :立即执行run()方法。不启动新的线程。
start() :执行run()方法时间不定，启动新的线程。
异常法 停止线程
MyThread.java
package thread;
public class MyThread extends Thread {
@Override
public void run() {
super.run();
try {
for (int i=0;i<500000;i++) {
if(this.isInterrupted()) {
System.out.println("已经是停止状态了，我要退出了！");
throw new InterruptedException();
}
System.out.println("i= "+ i);
}
System.out.println("我在for下面");
}catch (InterruptedException e) {
System.out.println("进MyThread.java类run方法中的catch了");
e.printStackTrace();
}
}
}
MyThreadRun.java
package thread;
public class MyThreadRun {
public static void main(String[] args) {
try {
MyThread thread = new MyThread();
thread.start();
Thread.sleep(2000); //当前正在执行的线程休眠2秒
thread.interrupt();
} catch (InterruptedException e) {
System.out.println("mian catch");
e.printStackTrace();
}
System.out.println("end！");
}
}
运行结果
Java中有两种线程：一种是用户线程，也就是非守护线程；另一种是守护线程。
守护线程是一种特殊的线程，当进程中不需要非守护线程了，则守护线程自动销毁。典型的守护线程是垃圾回收线程。
synchronized 关键字
SynchronizedTest.java
package thread;
public class SynchronizedTest {
synchronized public static void testMethod() {
System.out.println("调用了testMethod()");
}
public static void main(String[] args) throws InterruptedException {
testMethod();
}
}
在cmd中使用javap命令将class文件转换成字节码指令，参数-v用户输出附属信息，参数-c用户对代码进行反汇编。
Microsoft Windows [版本 10.0.17134.345]
(c) 2018 Microsoft Corporation。保留所有权利。
E:lick hread_demooutproduction hread_demo hread>javap -c -v SynchronizedTest.class
Classfile /E:/lick/thread_demo/out/production/thread_demo/thread/SynchronizedTest.class
Last modified 2019-8-4; size 703 bytes
MD5 checksum 3a9258d31bf2b018c71c4d7c9cb1ecb0
Compiled from "SynchronizedTest.java"
public class thread.SynchronizedTest
minor version: 0
major version: 50
flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
#1 = Methodref #7.#24 // java/lang/Object."<init>":()V
#2 = Fieldref #25.#26 // java/lang/System.out:Ljava/io/PrintStream;
#3 = String #27 // 调用了testMethod()
#4 = Methodref #28.#29 // java/io/PrintStream.println:(Ljava/lang/String;)V
#5 = Methodref #6.#30 // thread/SynchronizedTest.testMethod:()V
#6 = Class #31 // thread/SynchronizedTest
#7 = Class #32 // java/lang/Object
#8 = Utf8 <init>
#9 = Utf8 ()V
#10 = Utf8 Code
#11 = Utf8 LineNumberTable
#12 = Utf8 LocalVariableTable
#13 = Utf8 this
#14 = Utf8 Lthread/SynchronizedTest;
#15 = Utf8 testMethod
#16 = Utf8 main
#17 = Utf8 ([Ljava/lang/String;)V
#18 = Utf8 args
#19 = Utf8 [Ljava/lang/String;
#20 = Utf8 Exceptions
#21 = Class #33 // java/lang/InterruptedException
#22 = Utf8 SourceFile
#23 = Utf8 SynchronizedTest.java
#24 = NameAndType #8:#9 // "<init>":()V
#25 = Class #34 // java/lang/System
#26 = NameAndType #35:#36 // out:Ljava/io/PrintStream;
#27 = Utf8 调用了testMethod()
#28 = Class #37 // java/io/PrintStream
#29 = NameAndType #38:#39 // println:(Ljava/lang/String;)V
#30 = NameAndType #15:#9 // testMethod:()V
#31 = Utf8 thread/SynchronizedTest
#32 = Utf8 java/lang/Object
#33 = Utf8 java/lang/InterruptedException
#34 = Utf8 java/lang/System
#35 = Utf8 out
#36 = Utf8 Ljava/io/PrintStream;
#37 = Utf8 java/io/PrintStream
#38 = Utf8 println
#39 = Utf8 (Ljava/lang/String;)V
{
public thread.SynchronizedTest();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=1, locals=1, args_size=1
0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: return
LineNumberTable:
line 3: 0
LocalVariableTable:
Start Length Slot Name Signature
0 5 0 this Lthread/SynchronizedTest;
public static synchronized void testMethod();
descriptor: ()V
flags: ACC_PUBLIC, ACC_STATIC, ACC_SYNCHRONIZED
Code:
stack=2, locals=0, args_size=0
0: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream;
3: ldc #3 // String 调用了testMethod()
5: invokevirtual #4 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
8: return
LineNumberTable:
line 5: 0
line 6: 8
public static void main(java.lang.String[]) throws java.lang.InterruptedException;
descriptor: ([Ljava/lang/String;)V
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=0, locals=1, args_size=1
0: invokestatic #5 // Method testMethod:()V
3: return
LineNumberTable:
line 8: 0
line 9: 3
LocalVariableTable:
Start Length Slot Name Signature
0 4 0 args [Ljava/lang/String;
Exceptions:
throws java.lang.InterruptedException
}
SourceFile: "SynchronizedTest.java"
E:lick hread_demooutproduction hread_demo hread>
如果使用synchronized同步代码块，则使用monitorenter和monitorexit指令进行同步处理。
SynchronizedTest2 .java
package thread;
public class SynchronizedTest2 {
public void testMethod() {
synchronized (this) {
int age = 100;
System.out.println("调用了testMethod()");
}
}
public static void main(String[] args) throws InterruptedException {
SynchronizedTest2 test = new SynchronizedTest2();
test.testMethod();
}
}
Microsoft Windows [版本 10.0.17134.345]
(c) 2018 Microsoft Corporation。保留所有权利。
E:lick hread_demooutproduction hread_demo hread>javap -c -v SynchronizedTest2.class
Classfile /E:/lick/thread_demo/out/production/thread_demo/thread/SynchronizedTest2.class
Last modified 2019-8-4; size 898 bytes
MD5 checksum fdab454b47c6b381b641631535b6a367
Compiled from "SynchronizedTest2.java"
public class thread.SynchronizedTest2
minor version: 0
major version: 50
flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
#1 = Methodref #8.#32 // java/lang/Object."<init>":()V
#2 = Fieldref #33.#34 // java/lang/System.out:Ljava/io/PrintStream;
#3 = String #35 // 调用了testMethod()
#4 = Methodref #36.#37 // java/io/PrintStream.println:(Ljava/lang/String;)V
#5 = Class #38 // thread/SynchronizedTest2
#6 = Methodref #5.#32 // thread/SynchronizedTest2."<init>":()V
#7 = Methodref #5.#39 // thread/SynchronizedTest2.testMethod:()V
#8 = Class #40 // java/lang/Object
#9 = Utf8 <init>
#10 = Utf8 ()V
#11 = Utf8 Code
#12 = Utf8 LineNumberTable
#13 = Utf8 LocalVariableTable
#14 = Utf8 this
#15 = Utf8 Lthread/SynchronizedTest2;
#16 = Utf8 testMethod
#17 = Utf8 age
#18 = Utf8 I
#19 = Utf8 StackMapTable
#20 = Class #38 // thread/SynchronizedTest2
#21 = Class #40 // java/lang/Object
#22 = Class #41 // java/lang/Throwable
#23 = Utf8 main
#24 = Utf8 ([Ljava/lang/String;)V
#25 = Utf8 args
#26 = Utf8 [Ljava/lang/String;
#27 = Utf8 test
#28 = Utf8 Exceptions
#29 = Class #42 // java/lang/InterruptedException
#30 = Utf8 SourceFile
#31 = Utf8 SynchronizedTest2.java
#32 = NameAndType #9:#10 // "<init>":()V
#33 = Class #43 // java/lang/System
#34 = NameAndType #44:#45 // out:Ljava/io/PrintStream;
#35 = Utf8 调用了testMethod()
#36 = Class #46 // java/io/PrintStream
#37 = NameAndType #47:#48 // println:(Ljava/lang/String;)V
#38 = Utf8 thread/SynchronizedTest2
#39 = NameAndType #16:#10 // testMethod:()V
#40 = Utf8 java/lang/Object
#41 = Utf8 java/lang/Throwable
#42 = Utf8 java/lang/InterruptedException
#43 = Utf8 java/lang/System
#44 = Utf8 out
#45 = Utf8 Ljava/io/PrintStream;
#46 = Utf8 java/io/PrintStream
#47 = Utf8 println
#48 = Utf8 (Ljava/lang/String;)V
{
public thread.SynchronizedTest2();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=1, locals=1, args_size=1
0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: return
LineNumberTable:
line 3: 0
LocalVariableTable:
Start Length Slot Name Signature
0 5 0 this Lthread/SynchronizedTest2;
public void testMethod();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=2, locals=4, args_size=1
0: aload_0
1: dup
2: astore_1
3: monitorenter
4: bipush 100
6: istore_2
7: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream;
10: ldc #3 // String 调用了testMethod()
12: invokevirtual #4 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
15: aload_1
16: monitorexit
17: goto 25
20: astore_3
21: aload_1
22: monitorexit
23: aload_3
24: athrow
25: return
Exception table:
from to target type
4 17 20 any
20 23 20 any
LineNumberTable:
line 5: 0
line 6: 4
line 7: 7
line 8: 15
line 9: 25
LocalVariableTable:
Start Length Slot Name Signature
7 8 2 age I
0 26 0 this Lthread/SynchronizedTest2;
StackMapTable: number_of_entries = 2
frame_type = 255 /* full_frame */
offset_delta = 20
locals = [ class thread/SynchronizedTest2, class java/lang/Object ]
stack = [ class java/lang/Throwable ]
frame_type = 250 /* chop */
offset_delta = 4
public static void main(java.lang.String[]) throws java.lang.InterruptedException;
descriptor: ([Ljava/lang/String;)V
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=2, locals=2, args_size=1
0: new #5 // class thread/SynchronizedTest2
3: dup
4: invokespecial #6 // Method "<init>":()V
7: astore_1
8: aload_1
9: invokevirtual #7 // Method testMethod:()V
12: return
LineNumberTable:
line 11: 0
line 12: 8
line 13: 12
LocalVariableTable:
Start Length Slot Name Signature
0 13 0 args [Ljava/lang/String;
8 5 1 test Lthread/SynchronizedTest2;
Exceptions:
throws java.lang.InterruptedException
}
SourceFile: "SynchronizedTest2.java"
E:lick hread_demooutproduction hread_demo hread>
线程出现异常，会释放所有持有的锁。注意：类Thread.java中的suspend()和sleep(mills)方法被调用后并不释放锁。
volatile关键字，具有三个特性：
1.可见性： B线程能立马看到A线程更改的数据。
2.原子性：
3.禁止代码重排序。
synchronized关键字的三个特征：
1.可见性：synchronized关键字具有可见性。
2.原子性：使用synchronized实现了同步，同步实现了原子性，保证被同步的代码段在同一时间段只有一个线程在执行。
3.禁止代码重排序。
关键字synchronized和关键字volatile的使用场景总结：
1、当想实现一个变量的值被更改时，让其他线程能取得最新的值时，就要对变量使用volatile.
2、当多个线程对同一对象的同一实例变量进行操作时，为了避免出现非线程安全问题，就要使用synchronized.