ASP.Net+Android+IO开发S、.Net培训、期待与您交流!1、基础知识
进程:是指一个正在执行的程序,每一个进程执行,都有执行顺序,该顺序是一个执行路径,或者是一个控制单元
线程:就是进程中的一个独立的控制单元,线程控制着进程的执行,在线程执行中,至少有一线程执行
Vm 启动的时候有一个java.exe,该进程中至少有一个线程负责程序的执行,这个线程就是主线程
2.创建多线程
1》、我们可以利用java中的Thread类创建线程,Thread是程序中执行的线程。创建线程时,1》、必须继承Thread类; 2》、同时应该覆盖Thread类的run方法;3》、创建线程对象,即创建
所定义线程类的对象;4》开启线程,用对象的start方法(start的作用是:开启线程,并执行线程的run方法)
public class ThreadDemo1 extends Thread{
@Override
public void run() {
for(int i = 0; i< 60; i++)
{
System.out.println("thread run" +i);
}
}
}执行时调用对象的start方法
2》、线程的运行状态:五种状态,创建,运行,冻结,消亡,阻塞
3》、线程有名称,可以通过getName()的到线程名称,通过setName()来设置线程名称
自定义线程名称,我们通过调用父类的名称,亦可以通过;通过Thread.currentThread().getName()来获得当前线程的对象,currentThread是静态方法,获得那个线程是当前运行的对象
小实例:买票程序的实现:多个窗口实现同时买票,这样就有共享资源,所以在程序中我们应该用Thread来实现时,我们应该考虑票是临界资源
用Thread类实现时我们可以用静态变量来避免票被重复买
public class Ticket extends Thread //implements Runnable
{private static int ticket = 100;
public Ticket(String name)
{super(name);}
public void run() {
// TODO Auto-generated method stub
while(true){
if(ticket>0){
System.out.println(Thread.currentThread().getName()+" sale "+ticket--);
}}}}
4》、创建线程类的第二种方法:
步骤:1、定义实现Runnable接口的类
2、覆盖Runnable接口中的run方法(run方法中为线程要执行的程序代码)
3、通过Thread类来建立线程对象
4、将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数
为啥要将Runnable接口的子类对象传递给Thread的构造函数
原因:自定义的run方法所属的对象是Runnable接口的子类对象
所以要让线程去指定对象的run方法。就必须明确该run方法所属对象
5、调用Thread类的start方法开启线程并调用Runnable接口的run方法
public class ThreadDemo2 implements Runnable {
@Override
public void run() {
// TODO Auto-generated method stub
for(int i = 0; i< 60; i++)
{
System.out.println(Thread.currentThread().getName()+"thread run" +i);
}
}
}
开启线程 Runnable r1 = new ThreadDemo2(); new Thread(r1).start();
5》、实现方式和继承方式有什么区别?
实现方式避免了单继承的局限性,在定义线程时一般使用实现方式;继承Thread类线程代码存放在thread的子类的run方法中,而实现的线程代码在接口的子类run方法中
3、多线程的安全性问题,出现的原因
当多条语句在操作同一个线程共享数据时,一个线程对多条语句只执行了一部分,还没执行完成
另一个线程就获得了cpu的执行权,而执行其所要执行的语句,从而导致对共享数据的操作错误
解决方法:对多条共享数据的语句用同步方式处理,只能让一个线程在某一时间段内执行,执行完成后,再将cpu的使用权让出,这样在一个线程执行的过程中,其他线程不参与执行
1、java对于多线程的解决办法就是只用同步代码块的方式
synchronized(对象)
{
//需要同步的代码语句块
}
同步的代码块应该是那些操作共享数据的代码块
同步的原理:就是为资源的使用者上锁,当有线程使用共享资源是,对共享资源进行上锁,后来的线程等先来的线程将共享资源释放掉在使用共享资源,这样避免了CPU的使用权被后来
的线程占用
同步的前提是:1、必须要有两个或两个以上的线程共享同一资源;2、必须多个线程使用同一个锁,并且在同一段时间内只有一个线程在执行
线程的同步解决了多线程中存在的安全问题,但是它较为消耗资源
2、同步函数,带有synchronized修饰的函数为同步函数,同步函数也是用与解决多线程的安全性问题,同步函数使用的锁为this。只有两个锁相同时,对共享资源的访问才是安全的
public synchronized void add(int n)
{
sum += n;
try {
Thread.sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("sum = "+sum);
}
3、使用静态同步函数时,所用的锁不是this啦,而是Class的对象这时锁就是所定义类的class对应的对象Class clazz = Ticket1.class;clazz为同步函数的锁
4、java多线程同步在单例模式中的应用
单例模式的两种格式:饿汉式代码 懒汉式代码如下:(延时加载问题)
class Single{ class Single{
private static final Single s = new Single(); private static Single s = null;
private Single(){} private Single(){}
public static Single getInstance() public static Single getInstance()
{return s;} { if(s == null) s = new Single(); return s;}
} }
由上面代码可知道,当懒汉式用在多线程程序中时,可能会出现问题:有多个线程要实例化Single对象时,A线程判断s为空,线程进入睡眠状态;B线程在判断s还为空,这是B线程创建
了一个Single对象,A再次运行时,不在判断s是否为空,就创建s对象,违背了单例设计模式,我们可以有两种解决问题方式
class Single
{
private static Single s = null;
private Single(){};
public synchronized static Single getInstance()//这样每个进程进来都先判断锁是否开启,比较消耗资源
{
if(s == null) s = new Single(); return s;
}
}
第二种解决方案:使用代码块的方式,减少锁的判断 (延迟加载的单例设计模式)
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;}
}
}
}
5、多线程的死锁问题:出现的原因为同步中嵌套同步,而且两个锁不同引起的
6、线程间的通信
1》、等待唤醒机制,其实现主要靠wait()和notify()方法
其中wait方法让线程由运行状态变为冻结状态,冻结状态下,线程失去资源,没有执行的权利,只有当另外线程的唤醒(notify方法),才能从冻结状态转化为阻塞状态,
有执行所需要的资源,wait,notify(),notifyAll()都使用在同步中,因为要对持有监视器(同步锁)的线程做操作,所以要使用在同步中,因为只有同步才具有锁
synchronized(r)
{
if(!r.flag)
try{r.wait();}catch(Exception e){}//将线程至于冻结状态
System.out.println(r.name+"...."+r.sex);
r.flag = false;
r.notify();//拥有同样锁的线程可以唤醒拥有同样锁的等待进程,用notifyall可以唤醒拥有相同锁的其他等待进程
}
为什么这些操作的方法定义在Object类中?
因为这些方法在操作同步中线程时,都必须要有标志他们所操作线程只有的锁,因为只有被同一个锁上的线程才可以被同一个锁上的notify唤醒
即等待唤醒机制必须使用在同一个锁的同步代码块上,而锁可以是任意对象,因此wait和notify方法定义在Object中
2》、生产者消费者问题
在多个线程进行生产,多个进程进行消费的程序中我们应该用while进行判断,这样为了避免线程在为检测是否满足要求就去生产或者消费
while(flag)
try{this.wait();}catch(Exception e){}
this.name = name+"\t"+count++;
System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
flag = true;
this.notifyAll();//为了唤醒其他线程
在jdk1.5以后java中提供了新的解决方案。利用java.util.concurrent.locks包下提供的Lock接口和Condition接口,这两个接口相互配合,实现多线程之间资源共享的问题
Lock:替代了Synchronized
lock
unlock
newCondition()
Condition:替代了Object wait notify notifyAll
await();
signal();
signalAll();
实现的实例代码
private Lock lock = new ReentrantLock();
private Condition condition_produter = lock.newCondition();
private Condition condition_consumer = lock.newCondition();
public void set(String name)throws InterruptedException
{
lock.lock();
try
{
while(flag)
condition_produter.await();
this.name = name+"--"+count++;
System.out.println(Thread.currentThread().getName()+"\t生产者\t"+this.name);
flag = true;
condition_consumer.signal();
}
finally
{
lock.unlock();//释放锁的动作一定要执行。
}
}
7、停止线程
停止线程的原理:只有一种方法,即run方法的结束;开启多线程的运行,运行代码都是循环结构,所以我们只要控制住循环,就可以让run方法结束,也就是线程的结束
在特殊情况:当线程
8、守护线程:我么可以通过Thread类中的setDaemon()方法可以将线程设置为守护线程,这时线程为后台线程,当前台线程结束后,后台线程自动结束,注意:该方法在开启线程时调用
9、join是线程抢夺CPU的执行权,其他线程将等待该线程执行完成后,在回到阻塞状态
join的特点:当A线程执行到B线程的join方法时,A就会等待,等待B线程执行完,A才会执行,join可以用来临时加入线程执行
10、Priority和Yield
优先级,在java多线程中线程有优先级,优先级越高,其抢占到资源的概率越高
yield()
ASP.Net+Android+IO开发S、.Net培训、期待与您交流!