--------------------- android培训、java培训、期待与您交流! ----------------------
一丶多线程概述
1、进程:是一个正在执行中的程序。每一个进程执行,都有一个执行的顺序,该顺序是一个执行路径,或者叫一个控制单元。
2、线程:是进程中一个独立的控制单元,线程在控制着进程的执行。
3、一个进程中至少有一个线程。
4、JVM启动的时候会有一个进程java.exe。该进程中至少有一个进程负责java程序的执行,而且该线程运行的代码存在于main方法 中。该线程称之为主线程。
5、JVM启动不止一个线程,还有垃圾回收机制的线程。
二丶创建多线程-继承Thread类
1、创建线程两种方法(查找API可知)
2、第一种方法:继承Thread类。
/*
1.定义类继承Thread
2.复写Thread类中的run方法
3.调用线程的start方法,该方法有两个作用:
﹂启动线程,调用run方法。
4.运行结果每次都不一样,因为多个线程都获取cpu的执行权,cpu执行到谁,谁就运行。
在某一个时刻,只能有一个程序在运行(多核除外)。
cpu在做着快速切换,达到看上去是同时运行的效果。这就是多线程的一个特性:随机性。
*/
class Demo extends Thread
{
public void run()
{
for (int x=0;x<60;x++)
System.out.println("demo run--"+x);
}
}
class ThreadDemo
{
public static void main(String[] args)
{
Demo d=new Demo();//创建一个线程
d.start();//开启线程并执行该线程的run方法
//d.run();//仅仅是对象调用方法,而线程创建了,并没有执行。
for(int x=0;x<60;x++)
System.out.println("Hello World!--"+x);
}
}
3、为什么要覆盖run方法?|--Thread类用于描述线程,该类就定义了一个功能,用于存储线程要运行的代码,改存储功能就是run方法。
|--也就是说Thread类中的run方法,用于存储线程要运行的代码。
|--目的是将自定义代码存储在run方法,让线程运行。
4、线程练习
/*
创建2个线程,和主线程交替运行。
*/
class Test extends Thread
{
//private String name;
Test(String name)
{
//his.name=name;
super(name);
}
public void run()
{
for(int x=0;x<60;x++)
{
System.out.println(this.getName()+"test run..."+x);
}
}
}
class ThreadTest
{
public static void main(String[] args)
{
Test t1=new Test("one-");
Test t2=new Test("two-");
t1.start();
t2.start();
for(int x=0;x<60;x++)
{
System.out.println("main run..."+x);
}
}
}
5、线程都有自己默认的名称:Thread-编号,编号从0开始通过getName就可获取(查找API),setName可以设置名 称
6、售票示例
/*
需求:买票程序
多个窗口同时买票
*/
class Ticket extends Thread
{
private static int tick=100;//一般不使用静态,静态周期太长
public void run()
{
while(true)
{
if(tick>0)
{
System.out.println(Thread.currentThread().getName()+"....sale:"+tick--);
}
}
}
}
class TicketDemo
{
public static void main(String[] args)
{
Ticket t1=new Ticket();
Ticket t2=new Ticket();
Ticket t3=new Ticket();
Ticket t4=new Ticket();
t1.start();
t2.start();
t3.start();
t4.start();
}
}
三丶创建线程-实现Runnable接口
1、创建线程的第二种方法。
/*
需求:买票程序
多个窗口同时买票
1.定义类实现Runnable接口
2.覆盖Runnable接口中的run方法
﹂将线程要运行的代码存放在该run方法中
3.通过Thread类建立线程对象
4.将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数
﹂为什么将Runnable接口的子类对象传递给Thread的构造函数?
﹂因为自定义的run方法所属的对象是Runnable接口的子类对象,
﹂所以要让线程去指定对象的run方法,就必须明确该run方法所属的对象
5.调用Thread类的start方法开启线程并调用Runnable接口子类的run方法
*/
class Ticket implements Runnable
{
private int tick=100;
public void run()
{
while(true)
{
if(tick>0)
{
System.out.println(Thread.currentThread().getName()+"....sale:"+tick--);
}
}
}
}
class TicketDemo
{
public static void main(String[] args)
{
Ticket t=new Ticket();
Thread t1=new Thread();
Thread t2=new Thread();
Thread t3=new Thread();
Thread t4=new Thread();
t1.start();
t2.start();
t3.start();
t4.start();
}
}
2、实现方式和继承方式有什么区别?
﹂实现方式避免了单继承的局限性。
﹂建议定义线程时,使用实现方式。
|--继承Thread:线程代码存放在Thread子类run方法中。
|--实现Runnable:线程代码存放在接口的子类的run方法中。
四丶多线程的安全问题
1、当多条语句在操作同一个线程共享数据时,一个线程对多条语句只执行了一部分,还没有执行完成
﹂另一个线程参与进来执行,导致共享数据的错误。
2、解决方法:
|--对多条操作共享数据的语句,只能让一个线程都执行完,在执行过程中,其他线程不可以参与执行。
3、java对于多线程的安全问提供了专业的就解决方式。就是同步代码块。
synchronized(对象)
{
需要被同步的代码
}
五丶同步代码块
/*
synchronized(对象)
{
需要被同步的代码
}
对象如同锁,持有锁的线程可以在同步中执行,没有持有锁的线程
即使获取cpu的执行权,也进不去,因为没有获取锁
同步的前提:
1.必须要有两个或者两个以上的线程
2.必须是多个线程使用同一个锁
弊端:多个线程需要判断锁,较为消耗资源
*/
六丶同步函数
/*
需求:银行有一个金库。有两个储户分别存300元,每次存100,存三次。
目的:改程序是否有安全问题,如果有,怎么解决。
如何找到问题:
1.明确那些代码是多线程运行代码。
2.明确共享数据。
3.明确多线程运行代码中那些语句是操作共享数据的。
*/
class Bank
{
private int sum;
// Object obj=new Object();
public synchronized void add(int n)
{
// synchronized(obj)
// {
sum=sum+n;
try
{
Thread.sleep(10);
}
catch(Exception e)
{
}
System.out.println("sum"+sum);
// }
}
}
class Cus implements Runnable
{
private Bank b=new Bank();
public void run()
{
for (int x=0;x<3;x++)
{
b.add(100);
}
}
}
class BankDemo()
{
public static void main(String[] args)
{
Cus c=new Cus();
Thread t1=new Thread();
Thread t2=new Thread();
t1.start();
t2.start();
}
}
============================================================================================
/*
同步函数用的是哪一个锁?
函数需要被对象调用,那么函数都有一个所属的对象引用,就是this。
所以同步函数使用的锁匙this。
通过该程序进行验证:
使用两个线程来卖票
一个线程在同步代码块中
一个线程在同步函数中
都在执行卖票动作
如果同步说明没有错误的票
----------------------------------------------------------------
静态同步函数的琐是class对象
静态进内存,内存中没有本类对象,但是一定有该类对应的字节码文件对象。
类名.class 该类对象的类型是class
*/
class Ticket implements Runnable
{
private int tick=100;
Object obj=new Object();
boolean flag=true;
public void run()
{
if(flag)
{
while(true)
{
// show();
synchronized(this)
{
if(tick>0)
{
try
{
Thread.sleep(10);
}
catch(Exception e)
{
}
System.out.println(Thread.currentThread().getName()+"....code:"+tick--);
}
}
}
}
else
while(true)
show();
}
public synchronized void show()//this
{
if(tick>0)
{
try
{
Thread.sleep(10);
}
catch(Exception e)
{
}
System.out.println(Thread.currentThread().getName()+"....show:"+tick--);
}
}
}
class TicketDemo
{
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();
try
{
Thread.sleep(10);
}
catch(Exception e)
{
}
t.flag=false;
t2.start();
// t3.start();
// t4.start();
}
}
七丶线程间通讯-示例代码
1、其实就是多个线程在操作同一个资源,但是操作的动作不同。
/*
wait,notify(),notifyAll()都使用在同步中,因为要对持有监视器(锁)的线程操作。
所以要使用在同步中,因为只有同步才具有锁。
为什么这些操作线程的方法要定义在Object类中呢?
因为这些方法在操作同步中线程时,都必须要标识他们所操作线程只有的锁,
只有同一个锁上的被等待线程,可以被通一通锁上notify唤醒。
不可以对不同锁中的线程进行唤醒。
也就是说,等待和唤醒必须是同一个锁。
而锁可以是任意对象,所以可以被任意对象调用的方法定义在Object类中。
*/
class Res
{
private String name;
private String sex;
private boolean flag=false;
public synchronized void set(String name,String sex)
{
if(flag)
try
{
this.wait();
}
catch(Exception e)
{
}
this.name=name;
this.sex=sex;
flag=true;
notify();
}
public synchronized void out()
{
if(!flag)
try
{
this.wait();
}
catch(Exception e)
{
}
System.out.println(name+"......"+sex);
flag=flase;
notify();
}
}
class Input implements Runnable
{
private Res r;
// Object obj=new Object();
Input(Res r)
{
this.r=r;
}
public void run()
{
int x=0;
while(true)
{
/* synchronized(r)
{
if(r.flag)
try
{
r.wait();
}
catch(Exception e)
{
}
*/
if(x==0)
{
// r.name="mike";
// r.sex="man";
r.set("mike","man");
}
else
{
// r.name="丽丽";
// r.sex="女";
r.set("丽丽","女");
}
x=(x+1)%2;
// r.flag=true;
// r.notify();//唤醒
}
}
}
}
class Output implements Runnable
{
private Res r;
// Object obj=new Object();
Output(Res r)
{
this.r=r;
}
public void run()
{
while(true)
{
/* synchronized(r)
{
if(!r.flag)
try
{
r.wait();
}
catch(Exception e)
{
} */
r.out();
// System.out.println(r.name+"......"+r.sex);
// r.flag=false;
// r.notify();
}
}
}
}
class InputOutputDemo
{
public static void main(String[] args)
{
Res r=new Res();
new Thread(new Input(r)).start();
new Thread(new Output(r)).start();
/* Input in=new Input(r);
Output out=new Output(r);
Thread t1=new Thread(in);
Thread t2=new Thread(out);
t1.start();
t2.start(); */
}
}
八丶停止线程
/*
stop方法已经过时,那么如何停止线程?
只有一种,run方法结束。
开启多线程运行,运行代码通常是循环结构,只要控制循环,就可以让run方法
结束,也就是线程结束。
特殊状况:
当线程处于了冻结状态,就不会读取到标记,那么线程就不会结束
当没有指定的方式让冻结的线程恢复到运行状态时,这时需要对冻结进行清除,
强制让线程恢复到运行状态中来,这样就可以操作标记让线程结束。
Thread类提供的方法interrupt();
*/
class StopThread implements Runnable
{
private boolean flag=true;
public synchronized void run()
{
// while(flag)
{
try
{
wait();
}
catch(interruptedException e)
{
System.out.println(Thread.currentThread().getName()+"......Exception");
flag=false;
}
System.out.println(Thread.currentThread().getName()+"...run");
}
}
public void changeFlag()
{
flag=false;
}
}
class StopThreadDemo
{
public static void main(String[] args)
{
StopThread st=new StopThread();
Thread t1=new Thread();
Thread t2=new Thread();
t1.start();
t2.start();
int num=0;
while(true)
{
if(num++==60)
{
// st.changeFlag();
t1.interrupt();
t2.interrupt();
break;
}
System.out.println(Thread.currentThread().getName()+"......"+num);
}
System.out.println("over");
}
}
九丶守护线程
1、守护线程就是后台线程,后台线程不用刻意结束,前台线程完成后,自动结束。
--------------------- android培训、java培训、期待与您交流! ----------------------