Java #多线程技术#线程安全问题#Thread类、Runnable接口、synchronized关键字

多线程的目的就是为了让多个任务同时执行

真的是同时进行吗？CPU在执行多线程进程时，会切换线程执行，只不过切换速度非常快，让我们感觉是在同时执行

进程

• 正在运行的程序,当一个程序进入内存运行时，即变成了一个进程,具有一定的独立功能，进程是系统进行资源分配和调度的一个独立单位

线程

• 是进程中的执行单元，一个进程中至少有一个线程也可以存在多个线程

在Java中mian()所在的线程为主线程，如何创建子线程？

Thread 类

• 方法一：将类声明为Thread的子类，Thread类中含有run()、start()方法，将运行的程序写在run中，然后通过对象.start()方法创建子线程，如下面代码中的ThreadA、ThreadB

 Runnable 接口

• 方法二：将想要实现的线程类实现Runnable接口，重写Runnable接口中的run()方法，然后创建一个Thread对象，与线程类关联，如下面代码中的ThreadC

 注意：

• 推线使用方法二，方法一具有单继承的局限性
• Thread 它最好只当成一个执行路径 
• Runnable的实现子类 最好当成一个执行任务

public class ThreadDemo {
	
	public static void main(String[] args) {
		
		ThreadA t1=new ThreadA();
		ThreadB t2=new ThreadB();
		t1.start();
		t2.start();
		Thread t3=new Thread(new ThreadC());
		t3.start();
		for( int i=0; i<10;i++ ) {
			System.out.println("Threadmain:"+i);
		}
	}
}
class ThreadA extends Thread{
	
	@Override
	public void run() {
		
		for( int i=0; i<10;i++ ) {
			System.out.println("ThreadA:"+i);
		}
	
	}
}
class ThreadB extends Thread{
	
	@Override
	public void run() {
		
		for( int i=0; i<10;i++ ) {
			System.out.println("ThreadB:"+i);
		}
	
	}
}
class ThreadC implements Runnable{

	@Override
	public void run() {
		
		for( int i=0; i<10;i++ ) {
			System.out.println("ThreadC:"+i);
		}
	}
	
}

 执行结果如下，由于CPU的切换执行，执行结果不唯一

>>>
ThreadA:0
ThreadA:1
ThreadA:2
ThreadB:0
ThreadB:1
ThreadB:2
ThreadB:3
ThreadB:4
ThreadB:5
ThreadB:6
ThreadB:7
ThreadA:3
ThreadA:4
ThreadA:5
ThreadA:6
ThreadA:7
ThreadA:8
ThreadA:9
ThreadC:0
ThreadB:8
Threadmain:0
Threadmain:1
Threadmain:2
Threadmain:3
Threadmain:4
Threadmain:5
Threadmain:6
Threadmain:7
ThreadB:9
ThreadC:1
ThreadC:2
ThreadC:3
ThreadC:4
ThreadC:5
ThreadC:6
ThreadC:7
Threadmain:8
Threadmain:9
ThreadC:8
ThreadC:9

什么是线程安全？

当多个线程共享一个数据时，对共享数据操作有多余

如何处理？

• 将对共享数据操作的语句进行合适的原子化封装（原子语句是CPU执行的最小单位，CPU执行完原子语句才能切换其他线程）

synchronized

synchronized (锁对象) {
	需要被封装的代码
}

 锁对象 可以使任何一个类的对象 但是必须保证全局唯一

// 同步函数
public synchronized static String 函数名(){

}