Java笔记——多线程

1、多线程的定义
a、程序:是一个可执行的文件.
b、进程:是一个正在运行的程序.在内存中开辟了一块儿空间
c、线程:负责程序的运行,可以看做程序运行的一条通道或者一个执行单元.所以我们通常将进程的工作理解成线程的工作.
2、多线程的原理
3、多线程的实例----垃圾回收机制
4、多线程的创建方式
public class Demo{
public static void main(String[] args) {
//1.通过Thread的子类创建线程
//创建两个线程
MyThread thread1 = new MyThread(“bingbing”);//thread-0
MyThread thread2 = new MyThread(“yingying”);//thread-1
//通过start方法让线程工作
thread1.start();
thread2.start();//有三个线程,两个子线程一个主线程
for(int i=0;i<10;i++){
System.out.println(Thread.currentThread().getName()+" main i:"+i);
}
}
}

class MyThread extends Thread{
String myname;
public MyThread(String myname) {
super();
this.myname = myname;
}
@Override
public void run() {
/*
* 重写的run方法,作为任务区
* Thread.currentThread():获取的当前线程
* Thread.currentThread().getName():获取的是当前线程的名字,系统给的名字.
*/
for(int i=0;i<10;i++){
System.out.println(Thread.currentThread().getName()+" “+myname+” i:"+i);
}
}
}

5、多线程-----线程安全
同步代码块
synchronized(锁){
同步代码块
}
//对作为锁的对象的要求:1.必须是对象 2.必须保证被多个线程共享
//可以充当锁的:1.一个普通的对象 2.当前对象的引用–this 3.类的字节码文件

synchronized
1、synchronized关键字的作用域有二种：
1）是某个对象实例内，synchronized aMethod(){}可以防止多个线程同时访问这个对象的synchronized方法（如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchronized方法）。这时，不同的对象实例的synchronized方法是不相干扰的。也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法；
2）是某个类的范围，synchronized static aStaticMethod{}防止多个线程同时访问这个类中的synchronized static 方法。它可以对类的所有对象实例起作用。
2、除了方法前用synchronized关键字，synchronized关键字还可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。用法是: synchronized(this){/区块/}，它的作用域是当前对象；

3、synchronized关键字是不能继承的，也就是说，基类的方法synchronized f(){} 在继承类中并不自动是synchronized f(){}，而是变成了f(){}。继承类需要你显式的指定它的某个方法为synchronized方法；

6、多线程------线程通讯
sleep() 该线程进入等待状态,不释放锁
　　wait() 该线程进入等待状态,释放锁
　　notify() 随机唤醒一个线程
　　notifyAll() 唤醒全部线程
　　getName() 获取线程对象的名称。默认情况下，名字的组成 Thread-编号(编号从0开始)
　　setName(String name) 设置线程名称
　　currentThread() 返回当前正在执行的线程对象引用
　　sleep(Long time) 让当前线程休眠time毫秒
　　setDaemon(boolean on) 设置线程为守护线程，一旦前台(主线程),结束，守护线程就结束了
//join的优先级只比main高
join() 当前线程暂停, 等待指定的线程执行结束后, 当前线程再继续
　　join(int time)　　 当前线程暂停, 等待指定的线程执行time秒结束后, 当前线程再继续
　　yield() 暂停当前正在执行的线程对象，并执行其他线程。
　　getPriority() 获取线程优先级
　　setPriority(int newPriority)更改线程的优先级
生产者消费者

/*
*两类:
*1.单生产者单消费者 2.多生产者多消费者
*先研究多生产者多消费者
*分析:
*生产线程,消费线程有多个，生产任务,消费任务各有一个；产品一个。
*/
public class Demo5 {
public static void main(String[] args) {
//1.创建产品
Product1 product = new Product1();
//2.创建生产任务,消费任务
Producer1 producer = new Producer1(product);
Consumer1 consumer = new Consumer1(product);
//3.创建生产线程,消费线程
Thread t0 = new Thread(producer);
Thread t1 = new Thread(producer);
Thread t2 = new Thread(consumer);
Thread t3 = new Thread(consumer);
//4.开启线程
t0.start();
t1.start();
t2.start();
t3.start();
}
}

//创建产品类
class Product1{
String name;
double price;
int count;
boolean flag = false;//用来在唤醒与等待之间进行切换
//为生产准备数据
public synchronized void setProduce(String name,double price){
while (flag == true) {
try {
wait();//让生产线程等待
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
this.name = name;
this.price = price;
System.out.println(Thread.currentThread().getName()+" 生产了:"+name+" 产品的数量:"+count+" 产品的价格:"+price);
count++;
flag = ! flag;
//notify();//唤醒消费线程
notifyAll();
}
//为消费准备数据
public synchronized void consume() {
while (flag == false) {
try {
wait();//让消费线程等待
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName()+" 消费了:"+name+" 产品的数量:"+count+" 产品的价格:"+price);
flag = ! flag;
//notify();//唤醒生产线程
notifyAll();
}
}

//创建生产任务
class Producer1 implements Runnable{
Product1 product;
public Producer1(Product1 product) {
super();
this.product = product;
}
public void run() {
while (true) {
product.setProduce(“bingbing”, 10);
}
}
}
//创建消费任务
class Consumer1 implements Runnable{
Product1 product;
public Consumer1(Product1 product) {
super();
this.product = product;
}
public void run() {
while (true) {
product.consume();
}
}
}

7、多线程------Lock
a、lock是接口，通过他的子类工作
工作流程
>首先调用 Lock 的 Lock() 方法，获取锁
>进行同步操作的代码
>调用 Lock 的 unlock() 方方法释放锁
b、使用场景：当进行多生产者的消费者的时候，使用 lock，其他使用 synchronized

8、多线程------线程停止
a、通过一个标识结束线程
b、通过调用stop方法结束线程----有固有的安全问题,已经过时,不建议再使用、
c、调用interrupt()方法结束线程
>原理:线程可以调用wait()方法,让当前的线程处于钝化的状态(会立刻释放cpu,并且处于无法抢cpu的状态,但是当前的线程并没有死亡)//wait方法必须在同步状态下使用.
>调用interrupt方法就是将处于wait状态的线程停止.

9、多线程------线程守护
相当于后台线程，以来于前台，正常情况下，当前台线程结束的时候，不管守护线程有没有结束，都会立刻结束
/当程序调用setDaemon的时候,并且将参数设置成true,他就变成了守护线程./
thread.setDaemon(true);//这个方法一定要在start方法之前调用

10、多线程------join
join() 当前线程暂停, 等待指定的线程执行结束后, 当前线程再继续
join(int time)　　 当前线程暂停, 等待指定的线程执行time秒结束后, 当前线程再继续

11、多线程------线程的状态图