使用单例模式造成的内存泄漏

Posted 2020-09-05 安卓笔记侠

“管道”是java.io包的一部分。它是Java的特性，而不是android特有的。一条“管道”为两个线程建立一个单向的通道。生产者负责写数据，消费者负责读取数据。

下面是一个使用管道流进行通信的例子。

 1 public class PipeExampleActivity extends Activity {
 2  
 3     private static final String TAG = "PipeExampleActivity";
 4     private EditText editText;
 5  
 6     PipedReader r;
 7     PipedWriter w;
 8  
 9     private Thread workerThread;
10  
11     public void onCreate(Bundle savedInstanceState) {
12         super.onCreate(savedInstanceState);
13  
14         r = new PipedReader();
15         w = new PipedWriter();
16  
17         try {
18             w.connect(r);
19         } catch (IOException e) {
20             e.printStackTrace();
21         }
22  
23         setContentView(R.layout.activity_pipe);
24         editText = (EditText) findViewById(R.id.edit_text);
25         editText.addTextChangedListener(new TextWatcher() {
26             @Override
27             public void beforeTextChanged(CharSequence charSequence, int start, int count, int after) {
28             }
29  
30             @Override
31             public void onTextChanged(CharSequence charSequence, int start, int before, int count) {
32                 try {
33                     if(count > before) {
34                         w.write(charSequence.subSequence(before, count).toString());
35                     }
36                 } catch (IOException e) {
37                     e.printStackTrace();
38                 }
39             }
40  
41             @Override
42             public void afterTextChanged(Editable editable) {
43             }
44         });
45  
46         workerThread = new Thread(new TextHandlerTask(r));
47         workerThread.start();
48     }
49  
50     @Override
51     protected void onDestroy() {
52         super.onDestroy();
53         workerThread.interrupt();
54         try {
55             r.close();
56             w.close();
57         } catch (IOException e) {
58         }
59     }
60  
61     private static class TextHandlerTask implements Runnable {
62         private final PipedReader reader;
63  
64         public TextHandlerTask(PipedReader reader){
65             this.reader = reader;
66         }
67         @Override
68         public void run() {
69             while(!Thread.currentThread().isInterrupted()){
70                 try {
71                     int i;
72                     while((i = reader.read()) != -1){
73                         char c = (char) i;
74                         
75                         Log.d(TAG, "char = " + c);
76                     }
77  
78                 } catch (IOException e) {
79                     e.printStackTrace();
80                 }
81             }
82         }
83     }
84 }

在这个例子中，对EditText设置一个TextWatcher监听，一旦EditText的内容发生改变，就向“管道”中输入字符，它就是所谓的生产者。同时，有一个工作线程负责从管道中读取字符，它就是所谓的消费者。这样，就实现了UI线程和工作线程之间的数据通信。