多线程技术概述
线程与进程
进程
- 是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间
线程
- 是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行. 一个进程最少 有一个线程
线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分 成若干个线程
线程调度
分时调度
- 所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。
抢占式调度
- 优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。
CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核新而言，某个时刻，只能执行一个线程，而CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是 在同一时刻运行。其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高。
同步与异步
- 同步:排队执行 , 效率低但是安全.
- 异步:同时执行 , 效率高但是数据不安全.
并发与并行
- 并发：指两个或多个事件在同一个时间段内发生。
- 并行：指两个或多个事件在同一时刻发生（同时发生）
Java中线程实现的两种方式
实现Runnable接口
class MyThread implements Runnable{ // 实现Runnable接口，作为线程的实现类
private String name ; // 表示线程的名称
public MyThread(String name){
this.name = name ; // 通过构造方法配置name属性
}
public void run(){ // 覆写run()方法
for(int i=0;i<10;i++){
System.out.println(name + "运行，i = " + i) ;
}
}
};
public class Test {
public static void main(String args[]){
MyThread mt1 = new MyThread("线程A ") ; // 实例化对象
MyThread mt2 = new MyThread("线程B ") ; // 实例化对象
Thread t1 = new Thread(mt1) ; // 实例化Thread类对象
Thread t2 = new Thread(mt2) ; // 实例化Thread类对象
t1.start() ; // 启动多线程
t2.start() ; // 启动多线程
}
};
运行结果：
继承Thread类
class MyThread extends Thread{ // 继承Thread
private String name ; // 表示线程的名称
public MyThread(String name){
this.name = name ; // 通过构造方法配置name属性
}
public void run(){ // 覆写run()方法
for(int i=0;i<10;i++){
System.out.println(name + "运行，i = " + i) ;
}
}
};
public class Test {
public static void main(String args[]){
MyThread mt1 = new MyThread("线程A ") ; // 实例化对象
MyThread mt2 = new MyThread("线程B ") ; // 实例化对象
Thread t1 = new Thread(mt1) ; // 实例化Thread类对象
Thread t2 = new Thread(mt2) ; // 实例化Thread类对象
t1.start() ; // 启动多线程
t2.start() ; // 启动多线程
}
};
运行结果：
从程序可以看出，现在的两个线程对象是交错运行的，哪个线程对象抢到了 CPU 资源，哪个线程就可以运行，所以程序每次的运行结果肯定是不一样的，在线程启动虽然调用的是 start() 方法，但实际上调用的却是 run() 方法定义的主体。
####Thread 类和 Runable 接口的区别
实现Runnable接口创建多线程程序的好处：
1.避免单继承的局限性
一个类只能继承一个类（一个人只有一个亲爹）类继承了Thread类就不继承其他的类
实现了Runnable接口，还可以继承其他的类，实现其他的接口
2.增强程序的拓展性，降低了程序的耦合性
实现runnable接口的方式，把设置线程任务和开启新线程进行了分离
实现类中，重写了run方法：用来设置线程任务
创建Thread类对象，调用Start方法，用来开启新线程。
线程的状态变化
创建状态
在程序中用构造方法创建了一个线程对象后，新的线程对象便处于新建状态，此时它已经有了相应的内存空间和其他资源，但还处于不可运行状态。新建一个线程对象可采用Thread 类的构造方法来实现，例如 “Thread thread=new Thread()”。
就绪状态
新建线程对象后，调用该线程的 start() 方法就可以启动线程。当线程启动时，线程进入就绪状态。此时，线程将进入线程队列排队，等待 CPU 服务，这表明它已经具备了运行条件。
运行状态
当就绪状态被调用并获得处理器资源时，线程就进入了运行状态。此时，自动调用该线程对象的 run() 方法。run() 方法定义该线程的操作和功能。
阻塞状态
一个正在执行的线程在某些特殊情况下，如被人为挂起或需要执行耗时的输入/输出操作，会让 CPU 暂时中止自己的执行，进入阻塞状态。在可执行状态下，如果调用sleep(),suspend(),wait() 等方法，线程都将进入阻塞状态，发生阻塞时线程不能进入排队队列，只有当引起阻塞的原因被消除后，线程才可以转入就绪状态。
死亡状态
线程调用 stop() 方法时或 run() 方法执行结束后，即处于死亡状态。处于死亡状态的线程不具有继续运行的能力
线程名称的获取
class MyThread implements Runnable{ //实现Runnable接口
public void run(){
for(int i=0;i<3;i++){
System.out.println(Thread.currentThread().getName()+"运行, i="+i); //取得当前线程的名称
}
}
};
public class Test {
public static void main(String args[]){
MyThread my=new MyThread(); //定义Runnable子类对象
new Thread(my).start(); //系统自动设置线程名称
new Thread(my,"线程A").start(); //手工设置线程名称
}
};
运行结果：
线程的休眠
在程序中允许一个线程进行暂时的休眠，直接使用 Thread.sleep() 即可实现休眠。
class MyThread implements Runnable{ //实现Runnable接口
public void run(){
for(int i=0;i<8;i++){
try {
Thread.sleep(1000);//休眠1秒 1000的单位是毫秒
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"运行, i="+i); //取得当前线程的名称
}
}
};
public class Test {
public static void main(String args[]){
MyThread my=new MyThread(); //定义Runnable子类对象
new Thread(my,"线程").start(); //手工设置线程名称
}
};
运行结果：
同步
一个多线程的程序如果是通过 Runnable 接口实现的，则意味着类中的属性被多个线程共享，那么这样就会造成一种问题，如果这多个线程要操作同一个资源时就有可能出现资源同步问题。
解决办法1：
同步代码块
class MyThread implements Runnable { //实现Runnable接口
private int ticket = 5; // 假设一共有5张票
public void run() {
for (int i = 0; i < 100; i++) {
synchronized (this) { // 要对当前对象进行同步
if (ticket > 0) { // 还有票
try {
Thread.sleep(300); // 休眠300毫秒
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("卖票：ticket = " + ticket--);
}
}
}
}
};
public class Test {
public static void main(String args[]) {
MyThread mt = new MyThread(); // 定义线程对象
Thread t1 = new Thread(mt); // 定义Thread对象
Thread t2 = new Thread(mt); // 定义Thread对象
Thread t3 = new Thread(mt); // 定义Thread对象
t1.start();
t2.start();
t3.start();
}
};
运行结果：
解决办法2：
除了可以将需要的代码设置成同步代码块外，也可以使用 synchronized 关键字将一个方法声明为同步方法。
class MyThread implements Runnable { //实现Runnable接口
private int ticket = 5; // 假设一共有5张票
public void run() {
for (int i = 0; i < 100; i++) {
this.sale(); // 调用同步方法
}
}
public synchronized void sale() { // 声明同步方法
if (ticket > 0) { // 还有票
try {
Thread.sleep(300); // 休眠300毫秒
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("卖票：ticket = " + ticket--);
}
}
};
public class Test {
public static void main(String args[]) {
MyThread mt = new MyThread(); // 定义线程对象
Thread t1 = new Thread(mt); // 定义Thread对象
Thread t2 = new Thread(mt); // 定义Thread对象
Thread t3 = new Thread(mt); // 定义Thread对象
t1.start();
t2.start();
t3.start();
}
};
运行结果：
由此看出，结果是一样的。
死锁
死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。
画了个草图，一个房间俩个门，张三李四（两个线程）想穿过这个房间，他们两个都需要走两个门才能穿过去，张三拿着1号门的钥匙,李四拿着2号门的钥匙
当他们都进入房间想穿过第二道门的时候，张三想要李四的钥匙，李四想要张三的钥匙，他们都不愿意交出钥匙，结果就会导致谁都出不去，也就是死锁发生了，接下来直接上代码！
class Lock{
public static Object lock1 = new Object();//锁1
public static Object lock2 = new Object();//锁2
}
class MyThread1 extends Thread{
@Override
public void run() {
synchronized (Lock.lock1){//穿过第一道门
try {
System.out.println("张三通过1号门");
Thread.sleep(1000);//休眠1s，锁住lock1
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (Lock.lock2){//穿过第二道门
System.out.println("张三通过2号门");
}
}
}
}
class MyThread2 extends Thread{
@Override
public void run() {
synchronized (Lock.lock2){//穿过第2道门
try {
System.out.println("李四通过2号门");
Thread.sleep(1000);//休眠1s，锁住lock2
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (Lock.lock1){//穿过第1道门
System.out.println("李四通过1号门");
}
}
}
}
public class Test01 {
public static void main(String[] args) {
MyThread1 myThread1 = new MyThread1();
myThread1.start();
MyThread2 myThread2 = new MyThread2();
myThread2.start();
}
}
运行结果：
余下的代码不在执行，程序进入死锁状态。
3612
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
