------- android培训、java培训、java博客、java学习型技术博客、期待与您交流! ----------
同步函数使用的是哪一个锁呢?
函数需要被对象调用。那么函数有一个所属对象的引用。就是this。
所以同步函数使用的锁是this。
通过以下程序进行验证:
使用两个线程卖票。
一个线程在同步代码块中。
一个线程在同步函数中。
都在执行卖票动作。
class Ticket implements Runnable//extends Thread
{
privateintpiao=100;//一般不用static修饰达到共享100张票,因为生命周期太长
//Object obj=new Object();
booleanblog=true;
publicvoid run(){
while(true){
if(blog==true){
synchronized(this){//同步代码块
if(piao>0){
System.out.println(Thread.currentThread().getName()+"---"+piao--);
}
}
}
else{
show();
}
}
}
publicsynchronizedvoid show(){//同步函数
if(piao>0){
System.out.println(Thread.currentThread().getName()+"---"+piao--);
}
}
}
publicclass ThreadDemo2 {
publicstaticvoid main(String[] args) {
Ticket tic=new Ticket();
Thread t1=new Thread(tic);
Thread t2=new Thread(tic);
t1.start();
tic.blog=false;
t2.start();
}
}
静态同步函数使用的锁是Class对象
如果同步函数被静态修饰后,使用的锁是什么呢?
通过验证发现,不再是this,因为静态方法中也不可以定义this。
静态进内存时,内存中没有本类对象,但是一定有该类对应的字节码文件对象。
类名.class 该对象的类型是Class
静态的同步方法,使用的锁是该方法所在类的字节码文件对象。类名.class。
//单例模式,懒汉式
class Single{
privatestatic Single s=null;
private Single(){}
publicstatic Single getIncetance(){
if(s==null){
synchronized (Single.class) {
if(s==null)
s=new Single();
}
}
returns;
}
}
多线程-----死锁
同步中嵌套同步
class Test implements Runnable{
privatebooleanflag;
Test(boolean flag){
this.flag=flag;
}
publicvoid run(){
if(flag)
{
synchronized(MyLock.locka)
{
System.out.println("if locka");
synchronized(MyLock.lockb)
{
System.out.println("if lockb");
}
}
}
else{
synchronized(MyLock.lockb)
{
System.out.println("else lockb");
synchronized(MyLock.locka){
System.out.println("else locka");
}
}
}
}
}
class MyLock{
static Object locka=new Object();
static Object lockb=new Object();
}
publicclass BlockTest {
publicstaticvoid main(String[] args) {
Thread t1=new Thread(new Test(true));
Thread t2=new Thread(new Test(false));
t1.start();t2.start();
}
}
结果:if locka
else lockb
6、多线程通信及线程安全
需求:
我们分别定义两个线程,实现Runnable;还有一个类是资源类,里面包含name,sex;
其中一个线程是Input,只管录入资源信息,而另外一个线程Out负责往外去出资源;
为了保证取出与放入是同一份资源,那么涉及到线程安全问题,我们想到了synchronized,
锁机制,首先明确哪些是操作多线程的。存取为了保证同步,他们必须持有同种锁,而由代码可知,资源类Resdu对象是唯一的,因此他们的锁可以是 r
代码说明:
如何让资源共享呢?1、利用static修饰,但是由于静态生命周期过长,我们一般不这么做;
2、单例模式,可以实现,但是又有点麻烦;不可取
3、于是我们想到利用构造函数进行初始化(对象),传入同一份资源(对象),
便可达到目的。
class Res{
String name;
String sex;
}
class Input implements Runnable{
private Res r;
Input(Res r){//对象初始化
this.r=r;
}
publicvoid run(){
int temp=0;
while(true){
synchronized(r){
if(temp==0){
r.name="莉莉";
r.sex="女女";
}else{
r.name="tom";
r.sex="男男男";
}
}
temp=(temp+1)%2;
}
}
}
class Out implements Runnable{
private Res r;
Out(Res r){
this.r=r;
}
publicvoid run(){
while(true){
synchronized(r){
System.out.println(r.name+"----"+r.sex);
}
}
}
}
publicclass Synchronized {
publicstaticvoid main(String[] args) {
Res res=new Res();
Input in=new Input(res);
Out ou=new Out(res);
Thread t1=new Thread(in);
Thread t2=new Thread(ou);
t1.start();t2.start();
}
}
结果:
莉莉----女女
莉莉----女女
莉莉----女女
tom----男男男
tom----男男男
.....
7、多线程通信--等待唤醒机制
需求:实现了存取功能,但是线程是不规律的,当某一线程拿到锁就会不断执行,最后才到下一个线程运行,我们如何让资源输入一个,就拿出一个呢?此时就用到了等待唤醒机制。
wait(); notify(); notifiAll();
都使用在同步中,因为要对持有监视器(锁)的线程操作。
所以要使用在同步中,因为只有同步才具有锁。
为什么这些操作线程的方法要定义在Object类中呢?
因为这些方法在操作同步中线程时,都必须要标识它们所操作线程持有的锁,只有同一个锁上的被等待线程,才可以被同一个锁上的notify唤醒。不可以对不同锁中的线程进行唤醒。
也就是说,等待和唤醒必须是同一个锁。
而锁可以是任意对象,所以被任意对象调用的方法定义在Object类中。
class Res{
String name;
String sex;
booleanflag=false;//标识
}
class Input implements Runnable{
private Res r;
Input(Res r){
this.r=r;
}
publicvoid run(){
int temp=0;
while(true){
synchronized(r){
if(r.flag)
try{r.wait();}catch(Exception e){}//等待
if(temp==0){
r.name="莉莉";
r.sex="女女";
}else{
r.name="tom";
r.sex="男男男";
}
temp=(temp+1)%2;
r.flag=true;
r.notify();//唤醒
}
}
}
}
class Out implements Runnable{
private Res r;
Out(Res r){
this.r=r;
}
publicvoid run(){
while(true){
synchronized(r){
if(!r.flag)
try{r.wait();}catch(Exception e){}
System.out.println(r.name+"----"+r.sex);
r.flag=false;
r.notify();
}
}
}
}
publicclass Synchronized {
publicstaticvoid main(String[] args) {
Res res=new Res();
Input in=new Input(res);
Out ou=new Out(res);
Thread t1=new Thread(in);
Thread t2=new Thread(ou);
t1.start();t2.start();
}
}
结果:
莉莉----女女
tom----男男男
莉莉----女女
tom----男男男
莉莉----女女
.....
代码优化
class Res{
private String name;
private String sex;
privatebooleanflag=false;
publicsynchronizedvoid set(String name,String sex){//可能出现线程安全
if(flag)
try{this.wait();}catch(Exception e){}
this.name=name;
this.sex=sex;
flag=true;
this.notify();
}
publicsynchronizedvoid show(){
synchronized(this){
if(!flag)
try{this.wait();}catch(Exception e){}
System.out.println(name+"---"+sex);
flag=false;
this.notify();
}
}
}
class Input implements Runnable{
private Res r;
Input(Res r){
this.r=r;
}
publicvoid run(){
int temp=0;
while(true){
if(temp==0)
r.set("莉莉", "女女");
else
r.set("tom", "男男男");
temp=(temp+1)%2;
}
}
}
class Out implements Runnable{
private Res r;
Out(Res r){
this.r=r;
}
publicvoid run(){
while(true){
r.show();
}
}
}
publicclass Synchronized {
publicstaticvoid main(String[] args) {
Res r=new Res();
new Thread(new Input(r)).start();//匿名对象
new Thread(new Out(r)).start();
}
}
金典实例---生产者消费者
publicclass ProducerConsumerDemo {
publicstaticvoid main(String[] args) {
Resource r=new Resource();//资源
Producer pro=new Producer(r);//生产者
Consumer con=new Consumer(r);//消费者
Thread t1=new Thread(pro);
Thread t2=new Thread(con);
Thread t3=new Thread(pro);
Thread t4=new Thread(con);
t1.start(); t2.start(); t3.start(); t4.start();
}
}
class Resource{
private String name;
privateintcount=1;
privatebooleanflag=false;
publicsynchronizedvoid set(String name){
while(flag)
try{wait();}catch(Exception e){}
this.name=name+"--"+count++;
System.out.println(Thread.currentThread().getName()+"..生产者"+this.name);
flag=true;
this.notifyAll();
}
publicsynchronizedvoid out(){
while(!flag)
try{wait();}catch(Exception e){}
System.out.println(Thread.currentThread().getName()+"..消费者---"+this.name);
flag=false;
this.notifyAll();
}
}
class Producer implements Runnable{//生产
private Resource res;
Producer(Resource res){
this.res=res;
}
publicvoid run(){
while(true){
res.set("+商品+");
}
}
}
class Consumer implements Runnable{//消费
private Resource res;
Consumer(Resource res){
this.res=res;
}
publicvoid run(){
while(true){
res.out();
}
}
}
7、停止线程---interrupt
1、定义循环结束标记
因为线程运行代码一般都是循环,只要控制了循环即可。
2、使用interrupt(中断)方法。
该方法是结束线程的冻结作态,使线程回到运行作态中来。
注:stop方法已经过时,不在使用。
Stop方法已经过时,如何停止线程?
只有一种,让run方法结束。
开启多个线程运行,运行代码通常是循环结构。
只要控制住循环,就可以让run方法结束,也就是线程结束。
特殊情况:当线程处于了冻结状态,就不会读到标记,那么线程就不会结束。
当没有指定让冻结的线程恢复到运行状态时,这时需要对冻结线程进行清除。
强制让线程恢复到运行状态中来,这样就可以操作标记让线程结束。
Thread类提供该方法 interrupt();
class StopDemo implements Runnable{
privatebooleanflag=true;
publicsynchronizedvoid run(){
while(flag){
try{
wait();
}catch(InterruptedException e){
System.out.println(Thread.currentThread().getName()+"异常了");
flag=false;
}
System.out.println(Thread.currentThread().getName()+"run");
}
}
publicvoid changeFlag(){
flag=false;
}
}
publicclass StopThread {
publicstaticvoid main(String[] args) {
int num=0;
StopDemo sd=new StopDemo();
Thread t1=new Thread(sd);
Thread t2=new Thread(sd);
t1.start();t2.start();
while(true){
if(num++==60){
//sd.changeFlag();
t1.interrupt();
t2.interrupt();
break;
}
System.out.println(Thread.currentThread().getName());
}
System.out.println("主线程---OVER");
}
}
7、守护线程---setDaemon
setDaemon(boolean on):将该线程标记为守护线程或用户线程。
当正在运行的线程都是守护线程时,java虚拟机退出。
该方法必须在启动线程前调用。
随着主线程(前台线程)的结束,将线程中的无限循环结束,从而达到结束线程的目的,防止不被冻结。
8、join方法
当A线程执行到了B线程的join()方法时,A就会等待。等B线程都执行完,A才会执行。
Join可以用来临时加入线程执行。
9、线程的优先级
1.线程中的toString()覆盖了父类Object中的方法,返回该线程的字符串形式,包括线程名称,优先级和线程组。
2.yield() 暂停当前正在执行的线程对象,并执行其他线程。
3、线程组:谁开启的线程,那么这个线程就归为哪个组。如主线程也是一个组;
4、类ThreadGroup(String name):构造一个新的线程组。
5、优先级,代表抢夺资源的频率;
setPriority(int newPriority):更改线程优先级。值可选1——10;
public static final int ..
MAX_PRIORITY:线程可以具有的最高优先级。--10
MIN_PRIORITY:线程可以具有最低的优先级。--1
NORM_PRIORITY:分配给默认的优先级。------5
6、Runable r=new Runable(){
Public void run(){
for(int x=0;x<100;x++){
System.out.ptint(Thread.currentThread().getName());
}
}; 接口此处不能直接.start(),必须 new Thread(r).start();
}
------- android培训、java培训、java博客、java学习型技术博客、期待与您交流! ----------
如有疑问:http://edu.csdn.net/