java 接口的回调与 volatile关键字

最新推荐文章于 2025-01-26 14:39:35 发布

原创最新推荐文章于 2025-01-26 14:39:35 发布 · 297 阅读

0 ·

CC 4.0 BY-SA版权

java 专栏收录该内容

32 篇文章

订阅专栏

接口的回调

1./*
  * 利用接口实现 主线程处理逻辑
  * 子线程 去读取文件 并打印
  */
   //首先声明一个接口
  public interface ReadFileInter {
    public abstract void readFile(String string);
}
  // 创建一个功能类
  public class Read {
    // 使用接口对象作为参数
    public static void printFile(ReadFileInter inter) {
        // 开辟线程 读取文件
        new Thread(new Runnable() {
            @Override
            public void run() {
                StringBuilder sb = new StringBuilder();
                try {
                    FileReader fr = new FileReader("src/com/3g/hd/Read.java");
                    BufferedReader br = new BufferedReader(fr);
                    String string = "";
                    while ((string = br.readLine()) != null) {
                        sb = sb.append(string + "\n");
                    }
                    // 读文件
                    inter.readFile(sb.toString());
                    br.close();
                } catch (FileNotFoundException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }).start();;
    }
}
// 在main函数中测试一下
public static void main(String[] args) {
        System.out.println("主线程实现逻辑一...........");
        // 使用匿名对象方式传参数
        Read.printFile(new ReadFileInter() {
            // 匿名对象重写的方法
            @Override
            public void readFile(String string) {
                // 打印读取完的文件
                System.out.println(string);
            }
        });
        System.out.println("主线程实现逻辑二...........");
    }

volatile关键字

2.volatile 关键字 可以把线程中的值 修改后 立即同步出去(更新)
 public static void main(String[] args) {
        VolRunnable runnable = new VolRunnable();
        Thread t1 = new Thread(runnable);
        t1.start();
        // 写个循环卡住主线程
        // 子线程修改的值 没有同步到主线程中
        while (!runnable.isOver) {

        }
        System.out.println("主线程结束了");
    }
}

class VolRunnable implements Runnable{
    // volatile 关键字 可以把线程中的值 修改后 立即同步出去(更新)
    public volatile boolean isOver = false;
    int num = 0;
    @Override
    public void run() {
        while (!isOver) {
            num++;
            // 把线程的执行时间加大
            // 防止上面 还没执行到循环处 这里的标记值就已经改了
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName());
            if (num == 5) {
                isOver = true;
            }
        }
    }
}

join()方法

3.最后通过一个例子介绍一下Thread中的join()方法
 // 先执行子线程 再执行主线程
 public static void main(String[] args) {
        JRunnable runnable = new JRunnable();
        Thread t1 = new Thread(runnable);
        t1.start();
        try {
            // 拿到所有的cpu执行权 停在这里执行自己的方法
            // 等自己的方法执行完 在把cpu的执行权交回去
            t1.join(); 
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName() + i);
        }
        System.out.println("main is over");
    }
}

class JRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + i);
        }
    }
}