黑马程序员-----多进程

——- android培训、java培训、期待与您交流！ ———-

1、 进程、线程、多线程的区别：

1）进程：是一个正在执行中的程序，每一个进程执行都有一个执行顺序，该循序是一个执行路径，或叫控制单元。

2）线程：是进程中的一个独立的控制单元，线程在控制着进程的执行。

3）多线程：一个进程中可以有多个执行路径。

注意：一个进程中至少要有一个线程。

JVM启动时启动了多条线程，至少有两个线程可以分析的出来：

1.执行main函数的线程，该线程的任务代码都定义在main函数中。

2.负责垃圾回收的线程。

2、 创建线程的两种方法：

第一种方法：继承Thread类。

步骤：1）定义类继承Thread类

2）复写Thread类中的run方法

3）直接创建Thread的子类对象创建线程

4）调用线程的start方法（作用：启动线程；调用run方法）

class MyThread extends Thread
{
public void run()
{
//要在线程中执行的代码
for(int i=0;i<100;i++)
System.out.println("MyThread:"+i);
}
}

第二种方法：实现Runnable接口。

步骤：1）定义类实现Runnable接口

2）覆盖Runnable接口中的run方法

3）通过Thread类建立线程对象

4）将Runnable接口的子类对象作为实际参数传给Thread类的构造函数

5）调用Thread类的start方法开启线程并调用Runnable接口子类的run方法

class MyThread1 implements Runnable
{
public void run()
{
//要在线程中执行的代码
for(int i=0;i<100;i++)
System.out.println("MyThread:"+i);
}
}

完整代码示例演示：

package com.shan;
/**需求：建立一个多线程
* @param args
*/
public class Demo37 {
public static void main(String[] args)
{
System.out.println("启动主线程");
//启动第一个线程
Thread t1=new MyThread();
System.out.println("启动第一个线程");
t1.start();

//启动第二个线程
MyThread1  mt=new MyThread1();
Thread  t2=new Thread(mt);
System.out.println("启动第二个线程");
t2.start();

}

}
class MyThread extends Thread //创建线程的第一种方式
{
public void run()
{
//要在线程中执行的代码
for(int i=0;i<100;i++)
System.out.println("MyThread:"+i);
}
}
class MyThread1 implements Runnable  //创建线程的第二种方式
{
public void run()
{
//要在线程中执行的代码
for(int i=0;i<100;i++)
System.out.println("MyThread1:"+i);
}
}

3、 实现方式和继承方式有什么区别？（重点）

1） 实现方式好处在于避免了单继承的局限性，在定义线程时，建议使用实现方式

2） 线程代码存放的位置不一样

继承Thread类：线程代码存放在Thread子类的run方法中。

实现Runnable接口：线程代码存放在接口的子类的run方法中

4、 线程都有自己默认的名称。Thread-编号（该编号从0开始）

Static Thread currentThread():获取当前线程对象

getName():获取线程名称

设置线程名称：setName或者构造函数

5、线程安全问题产生的原因：

1.多个线程在操作共享的数据。

2.操作共享数据的线程代码有多条。

当一个线程在执行操作共享数据的多条代码过程中，其他线程参与了运算，就会导致线程安全问题的产生。

解决方案：

1）同步代码块：（java对于多线程的安全问题提供了专业的解决方式，就是同步代码块）

格式：synchronized（对象）
{需要被同步的代码；}

2） 同步函数：

格式：在函数上加上synchronized修饰符即可。

示例演示：模拟4个线程同时卖100张票

package com.shan;
/**
* 需求：模拟4个线程同时卖100张票。
* @author ling
*
*/
public class Demo38 {

public static void main(String[] args)
{
Ticket t=new Ticket();
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();
}

}
class Ticket implements  Runnable
{
private int num =1000;
Object obj=new Object();
public void run()
{
while(true)
{
synchronized(obj)
{
if(num>0)
{
System.out.println(Thread.currentThread().getName()+"...sale..."+num--);
}
}
}
}
}

6、 同步的前提：

1） 必须要有两个或两个以上的线程；

2） 必须保证同步中只有一个线程在运行；

好处：解决了多线程的安全问题

弊端：多个线程需要判断锁，较为消耗资源。

7、 同步有两种表现形式：

一种是同步代码块；一种是同步函数

8、 同步函数使用的锁是this，静态的同步函数使用的锁是该方法所在类的字节码文件对象，即：类名.class

示例演示：储户，两个，每个都到银行存钱，每次存100，共存三次。

classBank{
privateintsum;
publicsynchronizedvoidadd(intnum){//同步函数
sum=sum+num;
System.out.println("sum="+sum);
}
}
classCusimplementsRunnable{
privateBankb=newBank();
publicvoidrun(){
for(intx=0;x<3;x++){
b.add(100);
}
}
}

classBankDemo{
publicstaticvoidmain(String[]args){
Cusc=newCus();
Threadt1=newThread(c);
Threadt2=newThread(c);
t1.start();
t2.start();
}
}

单例模式中的懒汉式就用到了同步函数

class Single{
private static Single s = null;
private Single(){}
public static Single getInstance(){
if(s ==null){
synchronized(Single.class){
if(s == null)
s = new Single();
}
}
return s ;
}
}

9、 死锁：同步中嵌套同步，就出现死锁现象。

10、线程间的通信：（等待唤醒机制）

1）操作线程的方法有：wait()/notify()/notifyAll();

为什么这些操作线程的方法要定义在Object类中呢？

分析：因为这些方法在操作同步中的线程时，都必须要标识它们所操作线程特有的锁，只有同一个锁上的被等待线程可以被同一个锁上的notify唤醒，不可以对不同锁中的线程唤醒。也就是说，等待和唤醒必须是同一个锁。而锁可以是任意对象，所以可以被任意对象调用的方法定义在Object类中。

2） wait()和sleep()有什么区别？

分析：wait()：释放资源释放锁，没有执行权。

sleep()：释放资源不释放锁，有执行权。

示例演示：生产者—消费者

class Resource{
private String name ;
private String sex ;
private boolean flag = false;

public synchronized void set(String name,String sex){
if(flag )
try{
this.wait();
} catch(InterruptedException e){
e.printStackTrace();
}
this.name = name;
this.sex = sex;
flag = true ;
this.notify();
}

public synchronized void out(){
if(!flag )
try{
this.wait();
} catch(InterruptedException e){
e.printStackTrace();
}
System. out.println(name + "..." + sex);
flag = false ;
this.notify();
}
}
class Input implements Runnable{
Resource r;
Input(Resource r){
this.r = r;
}

public void run(){
int x = 0;
while(true ){
if(x == 0){
r.set( "mike","男" );
} else{
r.set( "lili","女" );
}
x = (x + 1)%2;
}
}
}

//输出
class Output implements Runnable{
Resource r;

Output(Resource r){
this.r = r;
}

public void run(){
while(true ){
r.out();
}
}
}

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

11、 停止线程

1） 定义循环结束标记。

因为线程运行代码一般都是循环，只要控制了循环即可。

2） 使用interrupt（中断）方法

该方法是结束线程的冻结状态，是线程回到运行状态中来。

总结：如何停止线程？

只有一种，run方法结束。 开启多线程运行，运行代码通常是循环结构。 只要控制住循环，就可以让run方法结束，也就是线程结束。

12、 守护线程

setDaemon（）方法是将该线程标记为守护线程或用户线程（后台线程）。当正在运行的线程都是守护线程时，java虚拟机自动退出。

该方法必须在启动线程前调用。

判断是否是后台线程：使用Thread对象的isDaemon()方法；

例如：

StopThread  st=new  StopThread  ();
Thread  t1=new Thread  (st);
Thread  t2=new Thread  (st);
t1.setDaemon(true);      //如果为true，则表示将该线程标记为守护线程
t2.setDaemon(true);
t1.start();
t2.start();

13、 join方法：

调用join方法的线程对象强制运行，该线程强制运行期间，其他线程无法运行，必须等到该线程结束后其他线程才可以运行。

join方法的重载方法:
join(long millis):
join(long millis,int nanos):

14、 线程的优先级：

每个线程都有优先级，优先级的高低只和线程获得执行机会的次数多少有关。

并非线程优先级越高的就一定先执行，哪个线程的先运行取决于CPU的调度;

默认情况下main线程具有普通的优先级，而它创建的线程也具有普通优先级。

Thread对象的setPriority(int x)和getPriority()来设置和获得优先级。
MAX_PRIORITY    :   值是10
MIN_PRIORITY    :   值是1
NORM_PRIORITY   :   值是5(主方法默认优先级)

15、 线程让步：（yield）

暂停当前正在执行的线程对象，把执行机会让给相同或更高优先级的其他线程，让线程可以你一个我一个的进行交替执行。

——- android培训、java培训、期待与您交流！ ———-