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

最新推荐文章于 2016-02-18 16:59:35 发布

ml5210

最新推荐文章于 2016-02-18 16:59:35 发布

阅读量305

点赞数

分类专栏： java基础多线程

本文链接：https://blog.csdn.net/ml5210/article/details/47948043

版权

java基础同时被 2 个专栏收录

9 篇文章 0 订阅

订阅专栏

多线程

1 篇文章 0 订阅

订阅专栏

　------- <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() ;

}

}