Java多线程:
进程:进行中的程序
线程:就是进程中一个负责程序执行的控制单元(执行单元)
一个进程中可以多执行路径，称之为多线程
一个进程至少一个线程
开启多个线程是为了同时运行多部分代码
每个线程都有自己运行的内容，这个内容成为线程要执行的任务
多线程的好处:解决了多部分同时运行的问题
多线程的弊端:线程太多回到效率的降低
其实应用程序的执行都是CPU在做着快速的切换完成的，这个切换是随机的
JVM启动时就启动了多个线程，至少有两个线程
1.执行main函数的线程
该线程的任务代码都定义在main函数里
2.负责垃圾回收的线程
如何创建一个线程:
方式一:继承Thread类
步骤：
1.创建一个类继承Thread类
2.重写Thread的run方法//重写run方法
3.直接创建Thread类的子类对象C创建线程
4.调用start方法开启线程并调用线程的任务run方法执行
class Demo extends Thread
{
private String name = "弟鸽";
Demo(String name)
{
super(name);
//this.name = name;
}
public void run(){
for(int i=1;i<10;i++)
{
for(long j= -199999999;j<199999999;j++){ }
system.out.println(name+"*****"+i+"--------"
+Thread.currentThread().getName());
}
}
}
main(){
Demo d1 = new Demo("脔割");
Demo d2 = new Demo("儿纸");
//d1.run();
//d2.run();
d1.start();
d2.start();
}
可以通过Thread的getName获取线程的名称 Thread—(0开始)
主线程的名称是 main
创建线程的目的是为了开启一条执行路径，去运行指定的代码和其他代码同时运行
而运行的指定代码就是这个执行路径的任务
JV创建的主线程的任务都定义在主函数里
自定义的线程的任务在run方法里；
Thread类用于描述线程，线程是 需要任务的，所以Thread类也对任务的描述，这个任务就通过Thread类中的run方法实现。也就是说，run方法就是封装自定义线程运行任务的函数。
run方法中定义的就是线程要运行的任务代码
开启线程是为了运行指定代码，所以只有继承Thread类，并复写run方法，将要运行的代码定义在run方法中即可。
run()和start()的区别:
1.start()可以启动一个新的线程
2.start()不能重复调用run()可以
3.start()中的run()代码可以不执行完就继续执行下面的代码，即进行了线程切换。直接调用run()方法必须等待其代码全部执行完才能继续执行下面的代码
4.start()实现了多线程，run()没有实现多线程
临时阻塞状态 具备执行资格但不具备执行权 正在等待执行权
↑ ↑
↓ ↑
进程--->start()--->运行--->sleep(time)--->冻结//释放执行权的同时
| ---> wait() --->↑ 释放执行资格
↓
stop()
|
↓
消亡
cpu执行资格: 可以被cpu处理，在处理队列中排队
cpu的执行权: 正在被cpu处理
创建线程的第二种方法:
1.定义类实现Runnable接口
2.覆盖接口种的run方法，将线程的任务代码封装到run方法中
3.通过Tread类创建对象，并将Runnable接口的子类对象作为Thread类的构造函数的参数进行传递。(原因是线程任务都封装在Runnable接口子类对象的run方法中，所以在线程对象创建时就得明确要运行的任务。)
4.调用线程对象的start方法开启线程
class Demo2 implements Runnable //准备扩展Demo2类的功能，让其中的内容作为线程的任务执行
//通过接口的形式完成
{
public void run()
{
show();
}
public void show(){
for(int i=1;i<10;i++)
{
for(long j= -199999999;j<199999999;j++){}
System.out.println(Thread.currentThread().getName());
}
}
}
main()
{
Demo2 d3 = new Demo2();
Thread t1 = new Thread(d3,"办证");
Thread t2 = new Thread(d3,"学妹介绍Q");
t1.start();
t2.start();
}
Runnable接口:将线程的任务进行了对象的封装
实现Runnable接口的好处:
1.将线程的任务从线程的子类中分离出来，进行了单独的封装
按照面向对象的思想将任务的封装成对象
2.避免了Java单继承的局限性
故较为常用的是实现Runnable
线程安全问题产生的原因:
1.多个线程在操作共享的数据
2.操作共享数据的代码有多条
当一个线程在执行操作共享数据的多条代码过程中，其他线程参与了运算
就会导致线程安全问题的产生
解决思路:
就是将多条操作共享数据的线程代码封装起来，当有线程在执行这些代码的时候，必须要当成线程把这些代码都执行完毕后，其他线程才可以 ------->局部代码块
在Java中用同步代码块就可以解决这个问题
synchronized(对象)
{
局部代码;
}
同步的好处:
解决了线程的安全问题
同步的弊端:
相对降低了效率，因为同步外的线程都会判断同步锁。
同步的前提:
同步中必须有多个线程吗，并使用同一个锁。
同步函数的锁是this
同步函数和同步代码块的区别:
1.同步函数的锁是固定的this
同步代码块的锁是任意的对象
建议使用同步代码块
当同步函数为static时，锁为this.getClass()即该函数所属字节码文件对象，可用getClass()方法获取，也可以用当前
类名.class 表示。
死锁:
class DeadLockTestDemo implements Runnable
{
private boolean flag;
DeadLockTestDemo(boolean flag)
{
this.flag = flag;
}
public void run()
{
if(flag)
{
while(true)
synchronized(MyLock.lockA)
{
System.out.println(Thread.currentThread().getName()+"--If--->LockA");
synchronized(MyLock.lockB)
{
System.out.println(Thread.currentThread().getName()+"--If--->LockB");
}
}
}
else
{
while(true)
synchronized(MyLock.lockB)
{
System.out.println(Thread.currentThread().getName()+"--Else--->LockB");
synchronized(MyLock.lockA)
{
System.out.println(Thread.currentThread().getName()+"--Else--->LockA");
}
}
}
}
}
class MyLock
{
public static final Object lockA = new Object();
public static final Object lockB = new Object();
}
public class DeakLockTest {
public static void main(String[] args) {
DeadLockTestDemo dlt1 = new DeadLockTestDemo(true);
DeadLockTestDemo dlt2 = new DeadLockTestDemo(false);
Thread t1 = new Thread(dlt1);
Thread t2 = new Thread(dlt2);
t1.start();
t2.start();
}
}
进程间的通信:
等待/唤醒机制
1.wait():让cpu处于冻结状态，被wait的线程会被存储到线程池中
2.notify(): 唤醒线程池中的一个线程(任意)
3.botifyAll():唤醒线程池中的所有线程
class Resource
{
String name;
int age;
boolean flag = false;
}
class Input implements Runnable
{
Resource r;
Input(Resource r)
{
this.r = r;
}
public void run()
{
int x = 0;
while(true)
{
synchronized(r)
{
if(r.flag)
try {
r.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if(x==0)
{
r.name = "脔割";
r.age = 18;
}
else
{
r.name = "弟鸽";
r.age = 17;
}
r.flag = true;
r.notify();
}
x = (x+1)%2;
}
}
}
class Output implements Runnable
{
Resource r = new Resource();
Output(Resource r)
{
this.r = r;
}
public void run()
{
while(true)
synchronized(r)
{
if(!r.flag)
try {
r.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(r.name+"--->"+r.age);
r.flag = false;
r.notify();
}
}
}
public class ResourceDemo {
public static void main(String[] args) {
Resource r = new Resource();
Input in = new Input(r);
Output out = new Output(r);
Thread t1 = new Thread(in);
Thread t2 = new Thread(out);
t1.start();
t2.start();
}
}
线程的wait();notify();notifuAll()定义在Oblect类中的原因是:
因为这些方法是监视器的方法，监视器其实就是锁。
锁可以是任意的对象，任意的对象调用的方式一定定义在Object类中
