黑马程序员_Java包和多线程

最新推荐文章于 2024-11-12 21:14:07 发布

faithtang

最新推荐文章于 2024-11-12 21:14:07 发布

阅读量424

点赞数

文章标签： java thread 多线程 class string exception

本文链接：https://blog.csdn.net/faithtang/article/details/7343359

版权

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