黑马程序员_Java包和多线程

----------- android培训、java培训、java学习型技术博客、期待与您交流! ------------

 

        包(package):包是一种封装形式,对类进行分类管理。给类提供多层命名空间。写在程序文件的第一行。类名的全称为:包名.类名。

包与包之间进行访问,被访问的包中的类以及类中的成员,需要被public修饰。不同包中的子类还可以直接访问父类中被protected权限修饰的成员。所以,包与包之间可以使用的权限只有两种:public,protected。

在同一个包中建立两个或两个以上类文件:新建一个java文件,建立同一个包名。

包可以建立多层次:如:package packb.tw.wl.hehe;

为了简化类名的书写,使用一个关键字:import(导入)。import导入的是包中的类。如:import packb.*;

建议:定义包名不要重复,可以使用url来完成定义。因为url是唯一的。

例如:package cn.itcast.demo;

Jar包:Java的压缩包。方便项目的携带。方便于使用,只要在classpath设置Jar路径即可。数据库驱动,SSH框架等都是以Jar包体现的。

将两个包pack和packa压缩成Jar包,可在DOS命令行:jar -cf  tw.jar  pack packa

 

多线程概述:

进程:是一个正在执行中的程序。每一个进程执行都有一个执行顺序。该顺序是一个执行路径,或者叫一个控制单元。

线程:就是进程中的一个独立的控制单元,线程在控制着进程的执行。

一个进程中至少有一个线程。

JVM启动的时候,会有一个进程java.exe。该进程中至少有一个线程负责java程序的执行,而且这个线程运行的代码存在于main方法中。该线程称之为主线程。其实JVM启动不止一个线程,还有负责垃圾回收机制的线程。

 

自定义线程:

1.创建线程的第一种方式:继承Thread类。

步骤:

a.定义类继承Thread类。

b.覆盖Thread类中的run方法。目的:将自定义代码存储在run方法中,让线程运行。

c.调用线程的start方法。该方法两个作用:启动线程,调用run方法。

多线程运行的特性:多线程运行时会互相抢夺cpu的执行权。谁抢到谁执行,至于执行多长,cpu说的算。这就造成了多线程的一个特性:随机性。

线程的运行状态:

 

 

 

获取线程对象以及名称:

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

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

获取当前线程名称:getName()

设置线程名称:setName()或者构造函数。

2.创建线程的第二种方式:实现Runnable接口。

步骤:

a.定义类实现Runnable接口。

b.覆盖Runnable接口中的run方法。将线程要运行的代码存放在该run方法中。

c.通过Thread类建立线程对象。

d.将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。因为,自定义的run方法所属的对象是Runnable接口的子类对象,所以要让线程去执行指定对象的run方法,就必须明确该run方法所属的对象。

e.调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。

实现方式和继承方式的区别:

继承Thread类:线程运行代码存放在Thread子类run方法中。

实现Runnable接口:线程运行代码存放在Runnable接口子类run方法中。

实现方式的好处:避免了单继承的局限性。

在定义线程时,建议使用实现方式。

 

多线程运行时的安全问题:

问题产生的原因:当多条语句在操作同一个线程共享数据时,一个线程对多条语句只执行了一部分,还没有执行完,另一个线程参与进来执行,导致共享数据的错误。

解决办法:对多条操作共享数据的语句,只能让一个线程都执行完。在执行过程中,其他线程不可以参与执行。

Java对于多线程的安全问题提供了专业的解决方式:就是同步。

同步的前提:

1.必须要有两个或两个以上的线程。

2.必须是多个线程使用同一个锁。

3.必须保证同步中只能有一个线程在运行。

同步的好处:解决了多线程的安全问题。

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

同步有两种表现形式:同步代码块,同步函数。

1.同步代码块:synchronized(对象)

                                  { 需要被同步的代码;}

对象如同锁。持有锁的线程可以在同步中执行。没有持有锁的线程即使获取cpu的执行权,也进不去,因为没有获取锁。

2.同步函数:如:public synchronized void method(){}

同步函数使用的锁是this。因为函数需要被对象调用,那么函数都有一个所属对象引用,就是this。

静态的同步函数,使用的锁是该函数所在类的字节码文件对象:类名.class。因为静态函数进内存时,内存中没有本类对象,但是一定有该类对应的字节码文件对象:类名.class,该对象的类型是class。

延迟加载单例设计模式示例:

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

 

死锁:同步嵌套同步,两个同步用不同的锁,导致程序卡死,叫死锁。

 

线程间通讯:其实就是多个线程在操作同一个资源,但是操作的动作不同。

wait(),notify(),notifyAll()都使用在同步中,因为要对持有监视器(锁)的线程操作,所以要使用在同步中,因为只有同步才具有锁。

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

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

wait()和sleep()的区别:

wait():释放资源,释放锁。

sleep():释放资源,不释放锁。

等待唤醒机制:有两个线程(存入线程和取出线程),同时操作一个容器。存入线程往容器中存入数据后等待,并唤醒等待的取出线程;取出线程从容器中取出数据后等待,并唤醒等待的存入线程。这就是等待唤醒机制。

代码示例:

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;
  this.notify();
 }
 public synchronized void get()
 {
  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;
 }
 public void run()
 {
  int x=0;
  while (true)
  {
   if(x==0)
    r.set("mike","man");
   else
    r.set("丽丽","女女女女女");
   x=(x+1)%2;
  }
 }
}
class Output implements Runnable
{
 private Res r;
 Output(Res r)
 {
  this.r=r;
 }
 public void run()
 {
  while(true)
  {
   r.get();
  }
 }
}
class InputOutputDemo2
{
 public static void main(String[] args)
 {
  Res r=new Res();
  new Thread(new Input(r)).start();
  new Thread(new Output(r)).start();
 }
}

 

生产者和消费者实例:生产者生产一个商品,消费者就消费一个商品。

代码示例:

class Resource
{
 private String name;
 private int count=1;
 private boolean flag=false;
 public synchronized void set(String name)
 {
  while(flag)
   try{this.wait();}catch(Exception e){}
  this.name=name+"--"+count++;
  System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);
  flag=true;
  this.notifyAll();
 }
 public synchronized void out()
 {
  while(!flag)
   try{this.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;
 }
 public void run()
 {
  while (true)
  {
   res.set("+商品+");
  }
 }
}
class Consumer implements Runnable
{
 private Resource res;
 Consumer(Resource res)
 {
  this.res=res;
 }
 public void run()
 {
  while(true)
  {
   res.out();
  }
 }
}
class ProducerConsumerDemo
{
 public static void 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(pro);
  Thread t3=new Thread(con);
  Thread t4=new Thread(con);
  t1.start();
  t2.start();
  t3.start();
  t4.start();
 }
}
注意:对于多个生产者和消费者,要定义while循环判断标记。因为让被唤醒的线程再一次判断标记。

            定义notifyAll(),因为需要唤醒对方线程。

在JDK5.0中提供了多线程升级解决方案:

将同步synchronized替换成显示Lock操作。将Object中的wait(),notify(),notifyAll()替换为Condition对象。该对象可以对Lock锁进行获取。

所以JDK5.0版本后,实现了显示的锁机制和显示的等待唤醒操作机制。

升级后的生产者和消费者代码示例:

import java.util.concurrent.locks.*;
class Resource
{
 private String name;
 private int count=1;
 private boolean flag=false;
 private Lock lock=new ReentrantLock();
 private Condition condition_pro=lock.newCondition();
 private Condition condition_con=lock.newCondition();
 public void set(String name)throws InterruptedException
 {
  lock.lock();
  try
  {
   while(flag)
    condition_pro.await();
   this.name=name+"--"+count++;
   System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);
   flag=true;
   condition_con.signal();
  }
  finally
  {
   lock.unlock();
  }
 }
 public void out()throws InterruptedException
 {
  lock.lock();
  try
  {
   while(!flag)
    condition_con.await();
   System.out.println(Thread.currentThread().getName()+"...消费者......."+this.name);
   flag=false;
   condition_pro.signal();
   
  }
  finally
  {
   lock.unlock();
  }
 }
}
class Producer implements Runnable
{
 private Resource res;
 Producer(Resource res)
 {
  this.res=res;
 }
 public void run()
 {
  while (true)
  try
  {
   res.set("+商品+");
  }
  catch(InterruptedException e){}
 }
}
class Consumer implements Runnable
{
 private Resource res;
 Consumer(Resource res)
 {
  this.res=res;
 }
 public void run()
 {
  while(true)
  try
  {
   res.out();
  }
  catch(InterruptedException e){}
 }
}
class ProducerConsumerDemo2
{
 public static void 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(pro);
  Thread t3=new Thread(con);
  Thread t4=new Thread(con);
  t1.start();
  t2.start();
  t3.start();
  t4.start();
 }
}

停止线程:

1.定义循环结束标记。因为线程运行代码一般都是循环,只要控制了循环即可。

2.使用interrupt方法。该方法是结束线程的冻结状态,强制使线程回到运行状态中来。

注:stop方法已经过时不再使用。

 

守护线程:依赖于前台线程存在,相当于后台线程。前台线程一结束,守护线程自动结束。

使用Thread类中setDaemon方法将线程标记为守护线程。

注意:

1.setDaemon方法必须在启动线程前(start()前)调用。

2.当运行的线程都为守护线程时,JVM退出,程序结束。

 

join方法:当A线程执行到了B线程的join方法时,A线程就会等待。等B线程都执行完,A线程才会执行。

join方法可以用来临时加入线程执行。

 

线程组:该线程由哪个线程开启就属于哪个线程组。一般属于main线程组。

优先级:优先级一共有1-10级。MAX_PRIORITY(10级),MIN_PRIORITY(1级),NORM_PRIORITY(默认优先级:5级)。一般线程优先级默认都为5级。

可以通过Thread类中setPriority方法设置线程的优先级。

yield方法:暂停当前正在执行的线程,执行其他线程。可以减缓线程运行的频率,有机会达到所有线程平均运行。

 

----------- android培训、java培训、java学习型技术博客、期待与您交流! ------------

 

 

           

 

 

你可能感兴趣的:(java,thread,多线程,class,string,exception)