A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 焦健 高级黑马   /  2013-1-22 19:14  /  1838 人查看  /  8 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

本帖最后由 焦健 于 2013-1-25 00:35 编辑

下面这一段代码如果不使用单利模式的获取方式,有没有办法在匿名内部类中获取到Res4的实例对象。
  1. public class Dsp {

  2.         /**
  3.          * @param args
  4.          */
  5.         public static void main(String[] args) {
  6.                 // TODO Auto-generated method stub
  7.                 //shouP();
  8.                 runs();


  9.         }

  10.         public static void runs() {
  11.                 new Thread(new  Runnable(){
  12.                         Res4 r;
  13.                         private void show(){
  14.                                 this.r=Res4.getInstance();
  15.                         }
  16.                         public void run() {
  17.                                 show();
  18.                                 int x=0;
  19.                                 while(true){
  20.                                         if(x==0){
  21.                                                 r.setName("make", "yemen");
  22.                                         }else{
  23.                                                 r.setName("丽丽", "女");
  24.                                         }
  25.                                         x=(x+1)%2;        
  26.                                 }
  27.                         };
  28.                 }).start();
  29.                 new Thread(new Runnable(){
  30.                         Res4 r;
  31.                         private void show(){
  32.                                 this.r=Res4.getInstance();
  33.                         }
  34.                         public void run() {
  35.                                 show();
  36.                                 while(true){
  37.                                         r.getName();
  38.                                 }
  39.                         };
  40.                 }).start();
  41.         }

  42.         public static void shouP() {
  43.                 Runnable r=new Runnable(){
  44.                         int x=100;
  45.                         @Override
  46.                         public void run() {
  47.                                 synchronized(this){
  48.                                         while(x>0){
  49.                                                 try {
  50.                                                         Thread.sleep(10);
  51.                                                 } catch (InterruptedException e) {
  52.                                                         e.printStackTrace();
  53.                                                 }
  54.                                                 System.out.println("x="+x--);
  55.                                         }
  56.                                 }
  57.                         }
  58.                 };
  59.                 new Thread(r).start();
  60.                 new Thread(r).start();
  61.         }

  62. }
  63. class Res4{
  64.         private String name;
  65.         private String sex;
  66.         private boolean flag=false;
  67.         private Res4(){}
  68.         private static  Res4 r=new Res4();
  69.         public  static Res4 getInstance(){
  70.                 return r;
  71.         }
  72.         public  synchronized void setName(String name ,String sex){
  73.                 if(flag)
  74.                         try {
  75.                                 wait();
  76.                         } catch (InterruptedException e) {
  77.                                 e.printStackTrace();
  78.                         }
  79.                 this.name=name;
  80.                 this.sex=sex;
  81.                 flag=true;
  82.                 notify();
  83.         }
  84.         public synchronized  void getName(){
  85.                 if(!flag)
  86.                         try {
  87.                                 wait();
  88.                         } catch (InterruptedException e) {
  89.                                 e.printStackTrace();
  90.                         }
  91.                 System.out.println(this.name+"-----"+this.sex);
  92.                 flag=false;
  93.                 notify();
  94.         }
  95. }
复制代码

评分

参与人数 1黑马币 +9 收起 理由
Rancho_Gump + 9 赞一个!

查看全部评分

8 个回复

倒序浏览
全局全局~~~
回复 使用道具 举报
王少雷 发表于 2013-1-22 19:18
全局全局~~~

什么全局,能详细说说吗。。
回复 使用道具 举报
哥们快去黑马了吧~~~
回复 使用道具 举报
高境 发表于 2013-1-22 19:21
哥们快去黑马了吧~~~

还早呢。。我准备17期呢,,要过年才行啊。。。你准备哪一期的啊??
回复 使用道具 举报
焦健 发表于 2013-1-22 19:25
还早呢。。我准备17期呢,,要过年才行啊。。。你准备哪一期的啊??

我就悲催了,我要大三下学期结束了才能去,我算了下,差不多20期
回复 使用道具 举报
Res4里面写一个无参构造。
在class Dsp类下面,写一个静态全局变量,如果是静态调用 就写静态的,不是静态内部调用 ,随便写一个权限。
回复 使用道具 举报
一、理解多线程

    多线程是这样一种机制,它允许在程序中并发执行多个指令流,每个指令流都称为一个线程,彼此间互相独立。线程又称为轻量级进程,它和进程一样拥有独立的执行控制,由操作系统负责调度,区别在于线程没有独立的存储空间,而是和所属进程中的其它线程共享一个存储空间,这使得线程间的通信远较进程简单。

    具体到java内存模型,由于Java被设计为跨平台的语言,在内存管理上,显然也要有一个统一的模型。系统存在一个主内存(Main Memory), Java中所有变量都储存在主存中,对于所有线程都是共享的。每条线程都有自己的工作内存(Working Memory),工作内存中保存的是主存中某些变量的拷贝,线程对所有变量的操作都是在工作内存中进行,线程之间无法相互直接访问,变量传递均需要通过主存完成。

    多个线程的执行是并发的,也就是在逻辑上“同时”,而不管是否是物理上的“同时”。如果系统只有一个CPU,那么真正的“同时”是不可能的。多线程和传统的单线程在程序设计上最大的区别在于,由于各个线程的控制流彼此独立,使得各个线程之间的代码是乱序执行的,将会带来线程调度,同步等问题。

二、在Java中实现多线程

    我们不妨设想,为了创建一个新的线程,我们需要做些什么?很显然,我们必须指明这个线程所要执行的代码,而这就是在Java中实现多线程我们所需要做的一切!

    作为一个完全面向对象的语言,Java提供了类 java.lang.Thread 来方便多线程编程,这个类提供了大量的方法来方便我们控制自己的各个线程。

    那么如何提供给 Java 我们要线程执行的代码呢?让我们来看一看 Thread 类。Thread 类最重要的方法是 run(),它为Thread 类的方法 start() 所调用,提供我们的线程所要执行的代码。为了指定我们自己的代码,只需要覆盖它!

  方法一:继承 Thread 类,重写方法 run(),我们在创建Thread 类的子类中重写 run() ,加入线程所要执行的代码即可。下面是一个例子:

public class TwoThread extends Thread {
    public void run() {
        for ( int i = 0; i < 10; i++ ) {
            System.out.println("New thread");
        }
    }
    public static void main(String[] args) {
        TwoThread tt = new TwoThread();
        tt.start();
        for ( int i = 0; i < 10; i++ ) {
            System.out.println("Main thread");
        }
    }
}


    这种方法简单明了,符合大家的习惯,但是,它也有一个很大的缺点,那就是如果我们的类已经从一个类继承,则无法再继承 Thread 类。

    方法二:实现 Runnable 接口

    Runnable 接口只有一个方法 run(),我们声明自己的类实现 Runnable 接口并提供这一方法,将我们的线程代码写入其中,就完成了这一部分的任务。但是 Runnable 接口并没有任何对线程的支持,我们还必须创建 Thread 类的实例,这一点通过 Thread 类的构造函数public Thread(Runnable target);来实现。下面是一个例子:

public class MyThread implements Runnable {
  int count=1, number;
  public MyThread(int num) {
  number = num;
  System.out.println("创建线程 " + number);
  }
  public void run() {//实现了接口的run()方法
  while(true) {
  System.out.println("线程 " + number + ":计数 " + count);
  if(++count== 6) return;
}
  }
  public static void main(String args[]) {
  for(int i = 0; i < 5; i++)
  new Thread(new MyThread(i+1)).start();
  }
}

    使用 Runnable 接口来实现多线程使得我们能够在一个类中包容所有的代码,有利于封装下面让我们一起来研究一下多线程使用中的一些问题。

三、线程的四种状态

    1、新状态:线程已被创建但尚未执行(start() 尚未被调用)。

    2、可执行状态:线程可以执行,虽然不一定正在执行。CPU 时间随时可能被分配给该线程,从而使得它执行。

    3、阻塞状态:线程不会被分配 CPU 时间,无法执行;可能阻塞于I/O,或者阻塞于同步锁。

    4、死亡状态:正常情况下run() 返回使得线程死亡。调用 stop()或 destroy() 亦有同样效果,但是不被推荐,前者会产生异常,后者是强制终止,不会释放锁。

    四、线程的优先级

    线程的优先级代表该线程的重要程度,当有多个线程同时处于可执行状态并等待获得 CPU 时间时,线程调度系统根据各个线程的优先级来决定给谁分配 CPU 时间,优先级高的线程有更大的机会获得 CPU 时间,优先级低的线程也不是没有机会,只是机会要小一些罢了。

    你可以调用 Thread 类的方法 getPriority() 和 setPriority()来存取线程的优先级,线程的优先级界于1(MIN_PRIORITY)和10(MAX_PRIORITY)之间,缺省是5(NORM_PRIORITY)。

点评

哥们,麻烦看明白我问的是什么在回复好吗。。  发表于 2013-1-23 15:12

评分

参与人数 1技术分 +1 收起 理由
Rancho_Gump + 1 赞一个!

查看全部评分

回复 使用道具 举报
杨玲 中级黑马 2013-1-24 23:43:52
9#
可以用引用传递嘛,就像毕老师视频里面的多线程间通信一样
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马