黑马程序员_java基础之多线程

　------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

进程就是正在运行的程序，是系统进行资源分配和调用的独立单位。

每一个进程都有它自己的内存空间和系统资源。

在一个进程内部又可以执行多个任务，而这每一个任务我们就可以看成是一个线程。是程序使用CPU的基本单位。

并行和并发。

前者是逻辑上同时发生，指在某一个时间内同时运行多个程序。

后者是物理上同时发生，指在某一个时间点同时运行多个程序。

Java程序运行原理

Java命令会启动java虚拟机，启动JVM，等于启动了一个应用程序，也就是启动了一个进程。

该进程会自动启动一个 “主线程” ，然后主线程去调用某个类的 main 方法。

所以 main方法运行在主线程中。

多线程举例：JVM

JVM启动至少启动了垃圾回收线程和主线程，所以是多线程的。

设置和获取线程优先级

public final int getPriority()

public final void setPriority(int newPriority)

线程的优先级仅仅表示线程获取CPU的时间片的几率,又由于线程在抢占CUP时间片的随机性,所以一两次的运行说明不了问题.

多线程程序实现的方式1

步骤:

a: 创建一个类,然后让这个类继承Thread

b: 重写run方法

c: 创建该类的对象

d: 启动线程类

多线程程序实现的方式2

步骤:

a: 创建一个类,然后让这个类去实现Runnable接口

b: 复写run方法

c: 创建定义的类的对象

d: 创建Thread类的对象,然后把C中的对象作为参数传递进来

e: 启动线程

这两种方式: 第二种方式相对比较友好一点点.因为其解决了继承带来的局限性

线程中产生问题的标准:

a: 是否是多线程环境

b: 是否存在共享数据

c: 是否有多条语句操作共享数据

如何来解决这个问题呢?

可以让一个线程执行操作共享数据的代码,然后其他的线程处于等待状态.

如何让一个线程执行这段代码的同时,其他线程处于等待状态呢?

需要使用同步代码块:

格式:

synchronized(对象){

需要被同步的代码 ;

}

同步代码块保证同步的作用的关键是这个对象,其实这个对象可以被看做成一把锁.有的书上把这个对象称之为监视器

这个同步代码块中的对象要保证多个线程使用的是一个

同步代码块的好处:
提高了数据的安全性

同步代码块的弊端:
每一个线程进来以后都需要判断同步锁,所有对应的效率比较低

同步代码块的锁是,是任意的对象

同步方法的锁对象到底是谁呢? 是this

静态同步方法的锁对象到底是谁呢? 是当前类的字节码文件对象

死锁案列

class MyLock {

public static final Object objA = new Object() ;

public static final Object objB = new Object() ;

}

class MyThread extends Thread {

private boolean flag ;

public MyThread(boolean flag){

this.flag = flag ;

}

@Override

public void run() {

if(flag){

synchronized(MyLock.objA){

System.out.println("true....objA......");

synchronized(MyLock.objB){

System.out.println("true....objB.....");

}

}

}else {

synchronized(MyLock.objB){

System.out.println("false....objB......");

synchronized(MyLock.objA){

System.out.println("false....objA.....");

}

}

}

}

}

public class ThreadDemo {

public static void main(String[] args) {

// 创建线程对象

MyThread t1 = new MyThread(true) ;

MyThread t2 = new MyThread(false) ;

// 启动线程

t1.start() ;

t2.start() ;

}

}

等待唤醒机制案例

class Student {

// 姓名

private String name ;

// 年龄

private int age ;

private boolean flag = false ;// 这个变量用来标记是否生产了学习

// 如果是true就表示有学生

public synchronized void set(String name , int age){

//判断

if(this.flag) {

try {

this.wait() ;
// wait会释放锁对象

} catch (InterruptedException e) {

e.printStackTrace();

}

}

this.name = name ;

this.age = age ;

// 更改标记为true

this.flag = true ;

// 唤醒消费者线程

this.notify() ;// 唤醒完毕以后每一个线程继续在抢占CPU的执行权

}

public synchronized void get() {

if(!this.flag){

try {

this.wait() ;

} catch (InterruptedException e) {

e.printStackTrace();

}

}

System.out.println(this.name + "---" + this.age );

// 把标记更改为false

this.flag = false ;

// 把生产者线程唤醒

this.notify() ;

}

}

class SetThread extends Thread {

private Student s ;

public SetThread(Student s){

this.s = s ;

}

private int n = 0 ;

@Override

public void run() {

while(true){

if(n % 2 == 0){

s.set("张三", 24 );

}else {

s.set("李四", 50) ;

}

n++ ;

}

}

}

class GetThread extends Thread {

private Student s ;

public GetThread(Student s){

this.s = s ;

}

@Override

public void run() {

while(true){

s.get() ;

}

}

}

class ThreadDemo {

public static void main(String[] args) {

// 创建一个学生对象

Student s = new Student() ;

// 创建线程

SetThread st = new SetThread(s) ;

GetThread gt = new GetThread(s) ;

// 启动线程

st.start() ;

gt.start() ;

}

}

线程的生命周期图