Android线程处理简述

原创作品，允许转载，转载时请务必以超链接形式标明文章   原始出处  、作者信息和本声明。否则将追究法律责任。 http://vaero.blog.51cto.com/4350852/782595

 Android线程处理简述

         附件工程是有关Android线程的，里面对的&错的方式都有。遇到报错那就对了，先熟悉了，以后才更清楚不是吗^^。

         还有，运行结果就不都截图了，懒人一个T^T。

 

一、基础篇

1）UI线程概念

           Android为单线程模型。当一个程序第一次启动时，Android会自动创建一个对应的主线程（Main Thread）。它负责把事件分派到相应的控件，用于用户与Android控件进行交互。所以通常又被叫做 UI线程。

         在开发Android应用时必须遵守单线程模型的原则： Android UI操作并不是线程安全的并且这些操作必须在UI线程中执行。

         简单表述为：1、不要阻塞UI线程；2、只能在主线程操作UI。

 

         详见Android帮助文档Dev Guide,左侧栏Processes and Threads。

 

2）UI线程示例

2.1）UI线程阻塞

         不考虑Android单线程模型，将所有任务都在该线程中执行，尤其是某些耗时操作，会使得整个用户界面被阻塞。从用户角度来看，就是按键或触屏后响应很慢甚至毫无响应。而且当应用程序阻塞的时间过长时，Android还会向用户提示一个无响应的对话框（不截了==）。

 

2.2）非主线程更新UI

         1、LogCat会报如下的错误消息：

         Uncaught handler: thread Thread-9 exiting due to uncaught exception。

         android.view.ViewRoot$CalledFromWrongThreadException: Only the original thread that created a view hierarchy can touch its views.

         2、Android会向用户提示一个强行关闭的对话框（又不截了==）。

 

2.3）非主线程更新UI

         三种方式：①Handler；②View.post(Runnable)；③Activity.runOnUiThread(Runnable)。

 

2.4）好了，开始动手测试吧^^

  
  
public class UIThreadActivity extends BaseActivity { 
 
    /** 标签 */ 
    private TextView textView; 
 
    /** Runnable */ 
    private Runnable runnable = new Runnable() { 
 
        @Override 
        public void run() { 
            logThreadId(); // 打印当前线程ID 
            textView.setText(tag + ", I'm Join!"); // 执行UI操作 
        } 
    }; 
 
    @Override 
    protected void onCreate(Bundle savedInstanceState) { 
        super.onCreate(savedInstanceState); 
        setContentView(R.layout.ui_thread); 
        tag = "UIThreadActivity"; 
        textView = (TextView) findViewById(R.id.textView); 
    } 
 
    /** 1.1 UI线程阻塞 */ 
    public void blockUi(View v) { 
        tag = "blockUi"; 
        logThreadId(); // 打印当前线程ID 
 
        /* 读取网页内容并显示 */ 
        textView.setText("开始读取网页！"); // 该步可能未显示，为什么？ 
        StringBuffer document = loadHtml("http://www.google.com"); // 耗时操作：读取网页源码 
        textView.setText(null == document ? "读取失败！" : document.toString()); // 显示网页源码 
        /** 
         * 1.观察按钮呈按下状态持续时间<br> 
         * 2.尝试在按钮呈按下状态时，进行按键和触屏操作<br> 
         */ 
    } 
 
    /** 1.2 非主线程更新UI */ 
    public void updateUi(View v) { 
        tag = "updateUi"; 
        new Thread(runnable).start(); 
    } 
 
    /** 2.1 方法1：Handler */ 
    public void methodOne(View v) { 
        tag = "methodOne"; 
        // Can't create handler inside thread that has not called 
        // Looper.prepare(); 
        final Handler handler = new Handler(); 
        new Thread(new Runnable() { 
            @Override 
            public void run() { 
                logThreadId(); // 打印当前线程ID 
                handler.post(runnable); 
                // handler.postDelayed(runnable, 1000); 
            } 
        }).start(); 
    } 
 
    /** 2.2 方法2: View.post(Runnable) */ 
    public void methodTwo(View v) { 
        tag = "methodTwo"; 
        new Thread(new Runnable() { 
            @Override 
            public void run() { 
                logThreadId(); // 打印当前线程ID 
                textView.post(runnable); 
                // textView.postDelayed(runnable, 1000); 
            } 
        }).start(); 
    } 
 
    /** 2.3 方法3：Activity.runOnUiThread(Runnable) */ 
    public void methodThree(View v) { 
        tag = "methodThree"; 
        new Thread(new Runnable() { 
            @Override 
            public void run() { 
                logThreadId(); // 打印当前线程ID 
                runOnUiThread(runnable); 
            } 
        }).start(); 
    } 
 
    /** 
     * 读取网页源码 
     */ 
    private StringBuffer loadHtml(String urlStr) { 
        try { 
            StringBuffer doc = new StringBuffer(); 
            URL url = new URL(urlStr); 
            URLConnection conn = url.openConnection(); 
            BufferedReader reader = new BufferedReader(new InputStreamReader( 
                    conn.getInputStream())); 
            String line = null; 
            while ((line = reader.readLine()) != null) 
                doc.append(line); 
            reader.close(); 
            return doc; 
        } catch (IOException e) { 
            e.printStackTrace(); 
        } 
        return null; 
    } 
 
} 

         亲，记得看Log日志出的线程id哦。（卖下萌，不介意吧？）

 

二、提高篇

1）Android消息处理机制

         熟悉Android开发的可能知道其应用程序都是由消息驱动的。参考了Windows的消息循环机制，Android系统通过Handler、Thread、Looper以及MessageQueue实现了这种消息机制。相关的类都被定义在了package android.os。

         推荐这篇博客咯—— 解析Android消息处理机制。（这个，那个，还建模==）

 

2）实用的消息处理方式

2.1）Thread实现消息循环

  
  
/** 1.1 Thread实现消息循环 */ 
public void methodOne(View v) { 
    tag = "methodOne"; 
 
    // 创建一个LooperThread对象，实现了消息循环 
    LooperThread thread = new LooperThread(); 
    // 必须启动这个线程 
    thread.start(); 
 
    // 创建一个消息对象并设置信息 
    Message msg = new Message(); 
    Bundle bundle = new Bundle(); 
    bundle.putString("key", "1.1 Thread实现消息循环"); 
    msg.setData(bundle); 
    // 发送消息对象 
    thread.mHandler.sendMessage(msg); 
} 
 
/** 实现消息循环的线程（在Android索引文档android.os.Looper的概述里有介绍） */ 
private class LooperThread extends Thread { 
    public Handler mHandler; 
 
    public void run() { 
        Looper.prepare(); 
 
        mHandler = new Handler() { 
            public void handleMessage(Message msg) { 
                // process incoming messages here 
                logThreadId(); // 打印当前线程ID 
                Log.e(tag, msg.getData().getString("key")); 
            } 
        }; 
 
        Looper.loop(); 
    } 
} 

         如果不使用Looper.prepare()及loop()的话，就不能创建Handler将消息处理加入到Looper中。LogCat会报“Can't create handler inside thread that has not called Looper.prepare();”的错误信息。

 

2.2）Handler与Looper相关联

         如果构造一个无参的Handler对象，它将自动与当前运行线程相关联。可以注意Handler相关例子中打印出的当前线程ID信息。

         而与Looper相关联，需要创建一个带参数的Handler对象。注意：此时线程类应该是一个HandlerThread类，一个Looper类的Thread类。

  
  
/** 1.2 Handler与Looper相关联 */ 
public void methodTwo(View v) { 
    tag = "methodTwo"; 
     
    // 生成一个HandlerThread对象，使用Looper来处理消息队列 
    HandlerThread thread = new HandlerThread("MyThread"); 
    // 必须启动这个线程 
    thread.start(); 
    // 将一个线程绑定到Handler对象上，则该Handler对象就可以处理线程的消息队列 
    MyHandler myhandler = new MyHandler(thread.getLooper()); 
    // 从Handler中获取消息对象 
    Message msg = myhandler.obtainMessage(); 
    // 设置消息对象信息 
    Bundle bundle = new Bundle(); 
    bundle.putString("key", "1.2 Handler与Looper相关联"); 
    msg.setData(bundle); 
    // 将消息对象发送给目标对象Handler 
    msg.sendToTarget(); 
} 
 
/** 重写Handler的消息处理方法 */ 
private class MyHandler extends Handler { 
 
    // 带有参数的构造函数 
    public MyHandler(Looper looper) { 
        super(looper); 
    } 
 
    @Override 
    public void handleMessage(Message msg) { 
        // process incoming messages here 
        logThreadId(); // 打印当前线程ID 
        Log.e(tag, msg.getData().getString("key")); 
    } 
} 

 

         所以，Wifi的HandlerThread，WifiHandler可以这样实例化（推荐博客有述）： 

  
  
HandlerThread wifiThread = new HandlerThread("WifiService"); 
wifiThread.start(); 
mWifiHandler = new WifiHandler(wifiThread.getLooper()); 

 

2.3）Hanlder与Thread实现异步

         在新线程中执行耗时操作，结束后通过Handler来更新UI。

  
  
/** 1.3 Hanlder与Thread实现异步 */ 
public void methodThree(View v) { 
    tag = "methodThree"; 
    /* 初始化进度条 */ 
    progressBar.setProgress(0); 
    progressBar.setVisibility(View.VISIBLE); 
    // 新线程执行某操作 
    new ProgressThread(0).start(); 
} 
 
/** 更新UI */ 
private Handler myHandler = new Handler() { 
    @Override 
    public void handleMessage(Message msg) { 
        progressBar.setProgress(msg.getData().getInt("key")); 
    } 
}; 
 
/** 新线程任务 */ 
private class ProgressThread extends Thread { 
 
    private int progress; 
 
    public ProgressThread(int progress) { 
        this.progress = progress; 
    } 
 
    @Override 
    public void run() { 
 
        try { 
            while (progress <= 100) { 
 
                progress += 5; // 进度+5 
 
                // doSomething(); // 执行耗时操作 
                Thread.sleep(100); 
 
                // 从Handler中获取消息对象 
                Message msg = myHandler.obtainMessage(); 
                // 设置消息对象信息 
                Bundle b = new Bundle(); 
                // 向Handler发送消息，更新UI 
                b.putInt("key", progress); 
                msg.setData(b); 
                myHandler.sendMessage(msg); 
            } 
        } catch (InterruptedException e) { 
            e.printStackTrace(); 
        } 
    } 
} 
 

3）Android异步线程——AsyncTask

         当任务需要复杂操作并频繁更新UI时，上述的非主线程访问UI方法会使得代码结构复杂和难以理解。所以Android1.5提供了一个工具类AsyncTask，用以创建与用户界面交互的长时间任务。也在被定义在了package android.os。

         AsyncTask定义了3种泛型类型： Params, Progress and Result；4个执行步骤：onPreExecute, doInBackground, onProgressUpdate and onPostExecute。

 

3.1）泛型类型

         1) Params，发送给后台任务处理的参数类型

         2) Progress，后台任务过程中发布的进度单位

         3) Result，后台任务结束后返回的结果类型

         想了解泛型类型的话，可参见我的 Java泛型应用浅析一文^^。

 

3.2）执行步骤

         1) onPreExecute()，该方法将在执行实际的后台操作前被UI thread调用。可以在该方法中做一些准备工作，如在界面上显示一个进度条。

         2) doInBackground=\'#\'" publishProgress方法来更新实时的任务进度。该方法是抽象方法，子类必须实现。

         3) onProgressUpdate(Progress...)，在publishProgress方法被调用后，UI thread将调用这个方法从而在界面上展示任务的进展情况，例如通过一个进度条进行展示。

         4) onPostExecute(Result)，在doInBackground执行完成后，onPostExecute方法将被UI thread调用，后台的计算结果将通过该方法传递到UI thread。

 

         onPostExecute的参数为doInBackground的返回值，类型由第三个泛型类型所指定。例子里仅是String，也可以是你自己的实体类、接口什么的。

 

3.3）使用准则

         1) Task的实例必须在UI thread中创建

         2) execute方法必须在UI thread中调用

         3) 不要手动的调用onPreExecute(), onPostExecute(Result)，

doInBackground=\'#\'" onProgressUpdate(Progress...)这几个方法

         4) 该task只能被执行一次，否则多次调用时将会出现异常

 

3.4）任务取消

         一个任务在任何时候都能够通过调用cancel(boolean)而取消。调用这个方法，将使得随后调用的isCancelled()返回true。并且在执行完 doInBackground(Object[])后，会去调用onCancelled(Object)而不再是onPostExecute(Object)方法。

         为了确保任务能够尽快的被取消，可以在doInBackground(Object[])内定期校验isCancelled()的返回值（例如在循环判断中）。

 

3.5）样例程序

  
  
/** 2 Android异步线程——AsyncTask */ 
public void methodFour(View v) { 
    tag = "methodFour"; 
    new LoadHtmlTask(this).execute("http://www.baidu.com"); // 执行读取网页任务 
    // new LoadHtmlTask(this).execute("http://www.google.com"); // 获取不到内容长度 
    // new LoadHtmlTask(this).execute("http://www.sina.com"); // 获取大量网页数据 
} 
 
/** 读取网页任务 */ 
private class LoadHtmlTask extends AsyncTask<String, Integer, String> { 
 
    private Context mContext; 
    private ProgressDialog dialog; // 进度框 
 
    public LoadHtmlTask(Context context) { 
        this.mContext = context; 
        initDialog(); // 初始化进度对话框 
    } 
 
    /** 初始化进度对话框 */ 
    private void initDialog() { 
        dialog = new ProgressDialog(mContext); 
        dialog.setMax(100); // 设置最大进度值 
        dialog.setTitle("Loading..."); // 设置标题 
        dialog.setCancelable(false); // 设为返回键不可取消 
        dialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL); // 设为进度条样式 
        // 增加取消按钮及其事件 
        dialog.setButton("取消", new DialogInterface.OnClickListener() { 
            public void onClick(DialogInterface dialog, int i) { 
                dialog.dismiss(); // 取消显示 
                cancel(true); // 取消并中断任务 
            } 
        }); 
    } 
 
    /** doInBackground之前，在主线程执行 */ 
    @Override 
    protected void onPreExecute() { 
        logThreadId("onPreExecute()"); // 打印当前线程ID 
        dialog.show(); // 显示进度对话框 
    } 
 
    /** onPreExecute()之后，在后台线程执行 */ 
    @Override 
    protected String doInBackground=\'#\'" /span>
        logThreadId("doInBackground"); // 打印当前线程ID 
        // 未传入参数直接返回 
        if (null == params || params.length <= 0) { 
            return "请确认输入了网址参数！"; 
        } 
        try { 
            // 创建HttpGet对象，params[0]为url 
            HttpGet httpGet = new HttpGet(params[0]); 
 
            // 发送Http Get请求，并返回HttpResponse对象 
            HttpResponse response = new DefaultHttpClient() 
                    .execute(httpGet); 
            // 判断响应状态，200表示成功响应 
            if (response.getStatusLine().getStatusCode() == 200) { 
                HttpEntity entity = response.getEntity(); // 获取返回结果 
 
                long length = entity.getContentLength(); // 获取内容长度（google获取不到） 
                boolean getLen = length > 0 ? true : false; // 判断是否获取了内容长度 
 
                InputStream is = entity.getContent(); // 获取响应内容 
                if (is != null) { 
                    ByteArrayOutputStream baos = new ByteArrayOutputStream(); 
                    byte[] buf = new byte[128]; 
                    int ch = -1; 
                    long count = 0; 
                    while ((ch = is.read(buf)) != -1 && !isCancelled()) { // 同时还未取消 
                        baos.write(buf, 0, ch); 
                        count += ch; 
                        if (getLen) { // 获取了内容长度时 
                            // 调用publishProgress()更新进度 
                            publishProgress((int) ((count / (float) length) * 100)); 
                        } 
                    } 
                    is.close(); 
                    baos.close(); 
                    return new String(baos.toByteArray()); // 返回结果 
                } 
                return "无返回内容！"; 
            } else { 
                return "服务器未响应或失败！"; 
            } 
        } catch (Exception e) { 
            e.printStackTrace(); 
        } 
        return "程序异常啦！"; 
    } 
 
    /** 调用了publishProgress()，在主线程执行 */ 
    @Override 
    protected void onProgressUpdate(Integer... values) { 
        // logThreadId("onProgressUpdate"); // 打印当前线程ID 
        dialog.setProgress(values[0]); 
    } 
 
    /** 未调用了cancel()，doInBackground()结束后，在主线程执行 */ 
    @Override 
    protected void onPostExecute(String result) { 
        logThreadId("onPostExecute(result)"); // 打印当前线程ID 
        dialog.dismiss(); // 取消显示 
        showMsg(result); // 显示结果 
    } 
 
    /** 调用了cancel()，doInBackground()结束后，在主线程执行 */ 
    @Override 
    protected void onCancelled() { 
        logThreadId("onCancelled"); // 打印当前线程ID 
        showMsg("用户取消了该任务！"); 
    } 
 
    /** 提示框显示消息 */ 
    private void showMsg(String message) { 
 
        // message内容过多时，提示框显示会延迟，例如sina 
        new AlertDialog.Builder(mContext) 
                .setTitle("消息") 
                .setMessage(message) 
                .setNegativeButton("关闭", 
                        new DialogInterface.OnClickListener() { 
                            @Override 
                            public void onClick(DialogInterface dialog, 
                                    int which) { 
                                dialog.dismiss(); 
                            } 
                        }).show(); 
    } 
 
} 

 

三、扩展篇

1）Service中的Toast

         Service中不能直接使用Toast提示信息，推荐如下方式：

  
  
private Handler handler; // Handler 
 
Override 
public void onCreate() { 
    Log.i("onCreate", "==onCreate=="); 
    super.onCreate(); 
 
    handler = new Handler(Looper.getMainLooper()); // 使用应用的主消息循环 
} 
 
/** 
 * Toast提示（service中toast不能直接显示） 
 */ 
private void showToast(final int resId, final Object... formatArgs) { 
    handler.post(new Runnable() { 
        public void run() { 
            Toast.makeText(getApplicationContext(), 
                    getString(resId, formatArgs), Toast.LENGTH_SHORT) 
                    .show(); 
        } 
    }); 
    // 以下方式只能显示一次 
    // Looper.prepare(); 
    // Toast.makeText(this, resId, Toast.LENGTH_SHORT).show(); 
    // Looper.loop(); 
} 

2）Java线程池

         一些简单常用的线程池，只需使用Executors类里面提供了一些静态工厂，如下：

         1）newSingleThreadExecutor：创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。

         2）newFixedThreadPool：创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。

         3）newCachedThreadPool：创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。

         4）newScheduledThreadPool：创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。

         5）newSingleThreadExecutor：创建一个单线程的线程池。此线程池支持定时以及周期性执行任务的需求。

         或者使用ThreadPoolExecutor，更加定制化地构造线程池。它们都被定义在package java.util.concurrent。

 

         线程池技术是为了减少频繁创建和销毁线程的系统开销，适用情况有：1）单个任务时间很短、处理请求巨大；2）有突发性大量任务请求；3）需要迅速响应的性能要求等。

 

  
  
public class TestPool implements Runnable { 
 
    private static final String TAG = "TestPool"; // 标记 
 
    private ExecutorService service; // 线程池 
 
    public TestPool() { 
        // service = Executors.newSingleThreadExecutor(); // 创建一个单任务线程池 
        service = Executors.newFixedThreadPool(3); // 创建最多同时运行3个任务线程池 
    } 
 
    /** 增加一个线程任务 */ 
    public void addTask() { 
        service.execute(this); 
    } 
 
    /** 线程任务 */ 
    @Override 
    public void run() { 
        log(1); // 显示日志 
        try { 
            Thread.sleep(5 * 1000); 
        } catch (InterruptedException e) { 
            e.printStackTrace(); 
        } 
        log(2); // 显示日志 
    } 
 
    /** 显示日志 */ 
    private void log(int which) { 
        String result = 1 == which ? "，任务开始！" : "，任务结束！"; 
        Log.e(TAG, "线程：" + String.valueOf(Thread.currentThread().getId()) 
                + result); 
    } 
 
} 

 

3）Java线程同步

          多线程并发访问同一数据时，就会有同步的需求。Java内在的同步机制包含：同步块（或方法）和 volatile 变量。同步块（或方法）通过synchronized关键字声明，而volatile可被看做是轻量级的synchronized。

 

          Java为每个object分配了一个monitor，相关方法如下：

          1）obj.wait()方法将使本线程挂起，并释放obj对象的monitor。只有其他线程调用obj对象的notify()或notifyAll()时，才可以被唤醒。

          2）obj.notifyAll()方法唤醒所有该obj对象相关的沉睡线程，然后被唤醒的众多线程开始竞争obj对象的monitor占有权，最终得到的那个线程会继续执行下去，但其他线程还将继续等待。

          3）obj.notify()方法是随机唤醒一个沉睡线程。

          4）wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用。

 

          没多线程不需要同步，有多线程不一定需要同步。

 

  
  
public class TestSync { 
 
    private Product product; 
    private Consumer ConsumerA, ConsumerB; 
 
    public TestSync() { 
        product = new Product(); 
        ConsumerA = new Consumer("小怪兽A", product); 
        ConsumerB = new Consumer("小怪兽B", product); 
    } 
 
    public void produce() { 
        synchronized (product) { 
 
            Log.e("TestSync", "\\(^o^)/，投掷一个果冻！"); 
            product.plus(); // 增加一个产品 
 
            /* 优先使用notifyAll()，更容易让jvm找到最适合被唤醒的线程 */ 
 
            // product.notify(); // 唤醒一个线程 
            product.notifyAll(); // 唤醒所有线程 
        } 
    } 
 
    public void start() { 
        ConsumerA.start(); 
        ConsumerB.start(); 
    } 
 
    public void stop() { 
        ConsumerA.stopEating(); 
        ConsumerB.stopEating(); 
 
        synchronized (product) { 
            product.notifyAll(); // 唤醒所有线程 
        } 
    } 
 
} 
 
/** 产品 */ 
class Product { 
 
    private int count = 0; // 产品数量 
 
    public Product() { 
    } 
 
    /** 是否无产品 */ 
    public boolean isNull() { 
        return count <= 0 ? true : false; 
    } 
 
    /** 增加产品 */ 
    public void plus() { 
        count++; 
    } 
 
    /** 减少产品 */ 
    public void minus() { 
        count--; 
    } 
 
} 
 
/** 消费者 */ 
class Consumer extends Thread { 
 
    private String name; // 消费者 
    private Product product; // 产品 
    private int count = 0; // 数量 
 
    private boolean waitEating = true; // 标记 
 
    public Consumer(String name, Product product) { 
        this.name = name; 
        this.product = product; 
    } 
 
    @Override 
    public void run() { 
        while (waitEating) { 
 
            synchronized (product) { 
 
                while (product.isNull() && waitEating) { 
                    try { 
                        Log.e(name, "（¯﹃¯），等待果冻中..."); 
                        product.wait(); 
                    } catch (InterruptedException e) { 
                        e.printStackTrace(); 
                    } 
                } 
 
                if (waitEating) { 
                    Log.e(name, "~\\(≧▽≦)/~，抢到了果冻！"); 
                    product.minus(); 
                    count++; 
                } 
            } 
        } 
        Log.e(name, "(～ o ～)~zZ，吃不下了。计：" + count); 
    } 
 
    public void stopEating() { 
        waitEating = false; 
    } 
 
} 

 

四、后记

         好吧，最后再截点图--！

 

 

 

 

 

         怎么一直是小怪兽A抢到的果冻？不应该啊T^T。

 

         ps：UI线程不太好阻塞，可以找个门户网站的主页（全是图==）、或者观察延迟时间。那个问题 “该步可能未显示，为什么？”不知道可以试下看看^^，为什么呢？

 

 

本文出自 “-_--___---_-” 博客，请务必保留此出处http://vaero.blog.51cto.com/4350852/782595