本文详细介绍了Java多线程的基本概念，包括进程与线程的区别，如何创建线程，以及多线程的随机性特征。通过示例代码演示了创建线程的方式，包括继承Thread类和实现Runnable接口，并探讨了它们的区别。此外，文章还深入分析了多线程安全问题及其解决方案，如使用synchronized关键字来防止竞态条件，并解释了多线程同步的前提和同步代码块的概念。最后，文章讨论了多线程死锁现象及其解决办法。
------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------多线程
多线程的概述
进程：是一个正在执行的的程序。每一个进程都有一个执行顺序，该顺序是一个执行路径，或者叫做一个控制单元。线程：进程的一个独立控制单元，线程在控制这进程的执行。一个进程中至少有个一进程。
例子：Java虚拟机启动时会有一个java.exe进程，该进程中至少有一个线程负责java程序的执行，而且这个线程运行的代码在main方法中，该线程称之为主线程。
扩展：JVM启动时不止一个线程，还有负责来垃圾回收机制的线程。
创建线程
创建线程的第一种方式：继承Thread类。
步骤：
1.定义类继承Thread2.复写Thread类中的run方法
目的：将自定义的代码存储在run方法中，让线程运行。
3.调用线程的start方法。该方法两个作用：启动线程，调用run方法。
发现运行结果每一次都不同
因为多个线程都在获取cpu的执行权。cpu执行到谁，谁就运行。
明确一点，在某一个时刻，只能有一个程序在运行，（多核除外）
cpu在做着快速的切换，以达到看上去是同时运行的效果。
我们可以形象的把多线程的运行形容为在互相抢夺cpu的执行权。
这就是多线程的一个特征：随机性。谁抢到谁执行，至于执行多长，cpu说了算。
class demo extends thread
{
public voidrun ()
{
for(int x=0;x<60;x++)
system.out.println("demo run---"+x);
}
}
class ThreadDemo
{
public static void main (string [] args)
{
demo d = new demo(); //创建好一个线程。
d.start();//开启线程并执行该线程的run方法。
//d.run()//仅仅是对象调用方法。而线程创建了，并没有执行。并且这样还是单线程，运行结束后才会执行main。
for(int x=0;x<60;x++)
system.out.println("main"+x);
}
} 创建线程-run和start特点：
为什么要覆盖run方法呢？
由于Thread类用于描述线程。该类就定义了一个功能，用于存储线程要运行的代码。该存储功能就是run方法。
也就是说Thread类中的run方法，用于存储线程要运行的代码。
run和start的区别：
run只执行方法，而start启动线程并执行run方法。
创建线程的第二种方式：实现Runnable接口
步骤：
1.定义类实现Runnable接口。
2.覆盖Runnable接口中的run方法。
3.通过Thread类建立线程对象。
4.将Runnable接口子类对象作为实参，传递给Thread类的构造方法。
5.调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。
售票例子：class Ticketimplements Runnable {
//200张票
privateintticke = 200;
Objiect obj=new Object();
publicvoid run() {
while(true) {
synchronized(obj){
if(ticket > 0)
System.out.println(Thread.currentThread().getName()+" "+ticket--);
}
}
}
}
public class ThreadDemo {
public staticvoid main(String[] args) {
Ticket t = newTicket();
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
Thread t3 = new Thread(t);
Thread t4 = new Thread(t);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
实现方式和继承方式有什么区别呢？
如果一个类中，部分代码运行多线程，部分代码不需要实现多线程，则该类实现Runnable类，然后在继承其他类。但是如果一个类继承了Thread类，则所有代码都是多线程的。
实现方式的好处：避免单继承的局限性。在定义多线程时，建议使用多线程。
两种方式的区别：
1.继承Thread类：线程代码存放在Thread子类的run方法中。
2.实现Runnable：线程代码存放在接口子类的run方法中。
多线程安全问题
通过分析，以上售票例子发现，打印出 0，-1，-2等错票。多线程的运行出现了安全问题。
问题的原因：
当多条语句在操作同一个线程共享数据时，一个线程对多条语句执行了一部分，还没有执行完，
另一个线程参与进来执行。导致共享数据的错误。
解决方法：
对多条操作共享数据的语句，只能让一个线程都执行完。在执行过程中，其他线程不可以参与执行。
Java对于对线程的安全问题提供了专业的解决方式：同步代码块
同步代码块：
synchronized(对象)
{
需要被同步的代码
}
对象如同锁。持有锁的线程可以在同步中进行。
没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。
如这部分修改：
publicvoid run() {
while(true) {
synchronized (new Object()) {
if(ticketNum > 0) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+" "+ticketNum--);
}
}
}
}
多线程同步的前提：
1.必须要有两个或者两个以上的线程。
2.必须是多个线程使用同一个锁。必须保证同步中只有一个线程在运行。
好处：解决多线程的安全问题。
弊端：多个线程都需要判断锁，较为消耗资源.
多线程的死锁
死锁：同步中嵌套同步。每个线程使用一个锁。
下面的例子，一个线程使用this锁，另一个线程使用Object对象的锁。在同步代码块中嵌套同步函数，在同步函数中嵌套同步代码块。
两个线程同时售票。一个线程使用this锁，另一个线程使用Object对象的锁。在同步代码块中嵌套同步函数，在同步函数中嵌套同步代码块。
class Ticket implements Runnable {
public booleanflag =true; //标记
Object obj = new Object();
private int ticketNum = 100; //100张票
public void run() {
if(flag) {
while(true) {
synchronized (obj) {
show();
}
}
}
else {
while(true)
show();
}
}
private synchronized void show() {
synchronized (obj) {
if(ticketNum > 0) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+" show() "+ticketNum--);
}
}
}
}
public class ThreadDemo {
public staticvoid main(String[] args) {
Ticket t = new Ticket();
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
t1.start();
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
t.flag = false;//避免两个线程都执行同步函数（show方法）
t2.start();
}
}
出现死锁原因：如果第1个线程执行同步代码块，在同步代码块中又有同步函数，所以第1个线程拥有Object锁的同时又获得this锁，此时如果第2个线程执行同步函数（获取this锁），由于第1个锁已经获取this锁了，所有两个线程都等待对象释放this锁，造成死锁。
扫一扫
475
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
