线程这块晕呼呼的！哪位大侠给条学习思路！并给个创建线程并启动线程的例子来自: Android客户端

感觉这个问题问的太笼统，还是多看看视频吧，看两遍就差不多了~~我的学习日志，希望对你有帮助

创建线程的第一种方式：继承Thread类。
步骤：
1，定义类继承Thread。
2，复写Thread类中的run方法。
        目的：将自定义代码存储在run方法。让线程运行。
3，调用线程的start方法。（api文档中显示：start() ：使该线程开始执行；Java 虚拟机调用该线程的 run 方法。）
        该方法两个作用：启动线程，调用run方法。
class Demo extends Thread//1，定义类继承Thread。
{//2，复写Thread类中的run方法。目的：将自定义代码存储在run方法。让线程运行。
        public void run()
        {
                for(int x=0; x<60; x++)
                        System.out.println("demo run----"+x);        }
}
class ThreadDemo
{
        public static void main(String[] args)
        {
                Demo d = new Demo();//建立好一个Demo对象就是创建好一个线程。
                d.start();//3，调用线程的start方法。开启线程并执行该线程的run方法。
                //d.run();如果不运行，d.start()，而是d.run()，那么运行的结果是先执行Demo再执行Hello World!。原因是执行d中run()，执行的run中的方法，用的是主线程，run仅仅是对象调用方法。而线程创建了，并没有运行。不使用start()是无法开启线程的。
                for(int x=0; x<60; x++)
                        System.out.println("Hello World!--"+x);
        }
}

通过对api的查找，java已经提供了对线程这类事物的描述。就Thread类。
创建线程的第一种方式：继承Thread类。
步骤：
1，定义类继承Thread。
2，复写Thread类中的run方法。
        目的：将自定义代码存储在run方法。让线程运行。
3，调用线程的start方法，
        该方法两个作用：启动线程，调用run方法。

例子：
class Demo extends Thread
{
        public void run()
        {
                for(int x=0;x<60;x++)
                        System.out.println("run-------"+x);
        }
}

class  ThreadDemo
{
        public static void main(String[] args)
        {
                Demo d = new Demo();
                d.start();

                for(int x=0;x<60;x++)
                        System.out.println("hello world----"+x);
        }
}

创建线程的第二种方式：实现Runable接口

步骤：
1，定义类实现Runnable接口
2，覆盖Runnable接口中的run方法。
        将线程要运行的代码存放在该run方法中。
3，通过Thread类建立线程对象。
4，将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
5，调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。

例子：
class Ticket implements Runnable//extends Thread
{
        private int tik=100;
        public void run()
        {
                while (true)
                {
                        if (tik>0)
                        {
                                System.out.println(Thread.currentThread().getName()+"..."+tik--);
                        }
                }
        }
}
class  ThreadTest2
{
        public static void main(String[] args)
        {
                Ticket t = new Ticket();

                Thread t1 = new Thread(t);
                Thread t2 = new Thread(t);
                Thread t3 = new Thread(t);
                Thread t4 = new Thread(t);

                t1.start();
                t2.start();
                t3.start();
                t4.start();
        }
}

确实，很多聪明的小马驹们都找到了学习方法，现在可以先去入学申请那里看看高手们整理的blog，挑出几个看着清爽，优秀的。
代码要及时敲，记得去阅读API，这个没了视频也一样可以通过API回顾知识点

学习的时候不要光听老师讲，听完了要自己去API里找到对应的类，和方法看看，想想。线程有两种实现方式：1、继承Thread类，并复写其run()方法，将要运行代码放到run()方法中。运行线程的时候，首先new线程的对象，并调用其start()方法。2、实现Runnable类，并复写其run()方法，将要运行代码放到run()方法中。运行线程的时候，首先new一个Thread类的对象，把实现了Runnable接口的类的对象当做参数传递给Thread对象，并调用Thread类的start()方法。
首先有的Thread类，但是java为了避免单继承的局限性，就定义了Runnable接口，Runnable定义了一个抽象的run()方法，让子类去实现。

　　看你说的对线程晕乎乎的，你要是只是知道如何创建线程和让它启动运行，这样肯定是不够的，得先弄清楚什么事线程吧。
　　 多线程是这样一种机制，它允许在程序中并发执行多个指令流，每个指令流都称为一个线程，彼此间互相独立。 线程又称为轻量级进程，它和进程一样拥有独立的执行控制，由操作系统负责调度，区别在于线程没有独立的存储空间，而是和所属进程中的其它线程共享一个存储空间，这使得线程间的通信远较进程简单。说的通俗一些就是相比单线程中cpu一直在执行一个进程，多线程中CPU在迸发执行多个程序片段，多个线程交替使用cpu，所以呢创建多线程，简单就是为你的程序编写多个能执行的片段，我理解的就是线程了。这样再查看API文档，创建一个线程并启动就不是什么太难的了。

创建的方法有两个：
扩展java.lang.Thread类。
　　创建Thread 的子类并重写run（）方法。run（）方法中的代码就是你线程需要执行的代码了。之后创建该类的实例对象。并用该对象调用start（）方法，这样，一个线程就启动了，重复这个动作就启动了多个线程。看下面的例子
　　class ThreadOne extends Thread
　　{
　　        public void run()
　　        {
　　                for (int i=0;i<40;i++ )
　　                {
　　                        System.out.println("ONE线程开始");
　　                }
　　        }
　　}
　　
　　class ThreadTwo extends Thread
　　{  
　　        public void run()
　　        {
　　                for(int i=0; i<40;i++)
　　                {
　　                        System.out.println("TWO线程开始");
　　               
　　                }
　　        }
　　}
　　class  ThreadDemo
　　{
　　        public static void main(String[] args)
　　        {
　　                ThreadOne one=new XianOne();
　　                ThreadTwo two=new XianTwo();
　　        one.start();
　　                tow.start();
　　
　　                for(int i=0;i<100;i++)
　　                {
　　                        System.out.println("主线程");       
　　                }
　　       
　　          
　　        }
　　}
　　
运行一下这段代码就会发现“主线程”、“ONE线程开始”、“TWO线程开始”这三个字符串交替出现。
　　
2、创建一个类实现java.lang.Runnable接口。
　　同样需要覆写run()方法，和上面的例子不同的是，多个线程执行的是同一个run（）方法。使用实现接口 Runnable 的对象创建一个线程时，启动该线程将导致在独立执行的线程中调用对象的 run 方法。看下面的例子：
　　
class MyThread implements Runnable
{
        public void run()
        {
                System.out.println("调用了run()方法");
                for(int i=0;i<=100;i++)
                {
                        System.out.println(Thread.currentThread().getName());
                }
        }
}
class MyThreadDemo
{
        public static void main(String[] args)
        {
                MyThread th=new MyThread();
                new Thread(th).start();
                new Thread(th).start();
                new Thread(th).start();
        }
}
运行一下你应该就能明白了

第一个方法是实现Runnable接口，如

1. 
   
2. //实现Runnable接口开启线程
   
3. public class Test2 {
   
4. 
   
5. public static void main(String[] args) {
   
6.   MyRunnable  m = new MyRunnable();
   
7.   Thread thread1 = new Thread (m);
   
8.   Thread thread2 = new Thread(m);
   
9.   thread1.start();
   
10.   thread2.start();
    
11.   System.out.println("main method");
    
12. }
    
13. }
    
14. 
    
15. class MyRunnable implements Runnable{
    
16. @Override
    
17. public void run() {
    
18.   // TODO Auto-generated method stub
    
19.   System.out.println("a thread start");
    
20. }
    
21. }

复制代码

第二是从Thread继承，如

1. 
   
2. /**
   
3. *从Thread继承,并重写run方法
   
4. * @author g
   
5. *
   
6. */
   
7. public class Test3 extends Thread {
   
8. 
   
9. public static void main(String[] args) {
   
10.   Test3 thread1 = new Test3();
    
11.   Test3 thread2 = new Test3();
    
12.   thread1.start();
    
13.   thread2.start();
    
14.   System.out.println("main method");
    
15. }
    
16. 
    
17. @Override
    
18. public void run() {
    
19.   System.out.println("a thread start");
    
20. }
    
21. }
    

复制代码