1、线程的创建方法：继承Thread类，实现Runable接口；
2、继承Thread类创建的线程，复写run方法即可，然后使用start方法启动线程；
3、实现Runable接口的线程，其实与线程没有直接关系，就算有了run方法，要明确与线程有直接关系的是Thread类，创建线程还是要依赖Thread类的，所以一个实现Runable的类并且有run方法，要是使用Thread的构造方法才能真正创建线程，然后必须使用Thread的start方法，才能启动一个线程；
4、线程的状态：新建、就绪、运行、死亡、阻塞；
5、线程的安全：设想一个共享资源也就是临界资源，多个线程同时访问的时候，由于CPU的执行权的不确定性，就会造成共享资源的不安全，解决办法很简单，就是将共享代码块加上同步，或者将一个共享函数加上同步，变为同步函数；这时候还要强调一点：加同步的时候需要一个锁对象，可以是任意对象，当然执行效率降低了；当一个临界资源被多线程访问的时候，并且线程是同步的，但是使用的锁对象不是同一个，就容易进入死锁的状态；
6、一个单例模式(安全高效)：懒汉式
class Single{
private Static Single s=null;
private Single(){}
Public Static Single getInstance(){
if(s==null){
synchronized(Single.class){
if(s==null)
return s= new Single();
}
}
}
}
7、线程的通信：在设想一种情况，一个共享资源，被多个线程访问，并且这个资源被各个线程的run方法所操作行为不一样，典型的便是生产者和消费者，一个生产一个消费，此时，便涉及到了线程的通信问题，当然解决办法依然是加同步，除此以外，你要考虑：当一个线程执行完后，如何通知其他相应的线程去执行，下面是一个简单完整的生产者和消费者的实例，体会一下线程间的通信不同之处：
class ProducerConsumerDemo{ public static void main(String[] args) { Resource r = new Resource(); Producer pro = new Producer(r); Consumer con = new Consumer(r); Thread t1 = new Thread(pro); Thread t2 = new Thread(pro); Thread t3 = new Thread(con); Thread t4 = new Thread(con); t1.start(); t2.start(); t3.start(); t4.start(); }}/*对于多个生产者和消费者。为什么要定义while判断标记。原因：让被唤醒的线程再一次判断标记。为什么定义notifyAll，因为需要唤醒对方线程。因为只用notify，容易出现只唤醒本方线程的情况。导致程序中的所有线程都等待。*/class Resource{ private String name; private int count = 1; private boolean flag = false; // t1 t2 public synchronized void set(String name) { while(flag) try{this.wait();}catch(Exception e){}//t1(放弃资格) t2(获取资格) this.name = name+"--"+count++; System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name); flag = true; this.notifyAll(); } // t3 t4 public synchronized void out() { while(!flag) try{wait();}catch(Exception e){}//t3(放弃资格) t4(放弃资格) System.out.println(Thread.currentThread().getName()+"...消费者........."+this.name); flag = false; this.notifyAll(); }}class Producer implements Runnable{ private Resource res; Producer(Resource res) { this.res = res; } public void run() { while(true) { res.set("+商品+"); } }}class Consumer implements Runnable{ private Resource res; Consumer(Resource res) { this.res = res; } public void run() { while(true) { res.out(); } }}
下面给出最新版本的实例：
import java.util.concurrent.locks.*;class ProducerConsumerDemo2{ public static void main(String[] args) { Resource r = new Resource(); Producer pro = new Producer(r); Consumer con = new Consumer(r); Thread t1 = new Thread(pro); Thread t2 = new Thread(pro); Thread t3 = new Thread(con); Thread t4 = new Thread(con); t1.start(); t2.start(); t3.start(); t4.start(); }}/*JDK1.5 中提供了多线程升级解决方案。将同步Synchronized替换成现实Lock操作。将Object中的wait，notify notifyAll，替换了Condition对象。该对象可以Lock锁 进行获取。该示例中，实现了本方只唤醒对方操作。Lock:替代了Synchronized lock unlock newCondition()Condition：替代了Object wait notify notifyAll await(); signal(); signalAll();*/class Resource{ private String name; private int count = 1; private boolean flag = false; // t1 t2 private Lock lock = new ReentrantLock(); private Condition condition_pro = lock.newCondition(); private Condition condition_con = lock.newCondition(); public void set(String name)throws InterruptedException { lock.lock(); try { while(flag) condition_pro.await();//t1,t2 this.name = name+"--"+count++; System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name); flag = true; condition_con.signal(); } finally { lock.unlock();//释放锁的动作一定要执行。 } } // t3 t4 public void out()throws InterruptedException { lock.lock(); try { while(!flag) condition_con.await(); System.out.println(Thread.currentThread().getName()+"...消费者........."+this.name); flag = false; condition_pro.signal(); } finally { lock.unlock(); } }}class Producer implements Runnable{ private Resource res; Producer(Resource res) { this.res = res; } public void run() { while(true) { try { res.set("+商品+"); } catch (InterruptedException e) { } } }}class Consumer implements Runnable{ private Resource res; Consumer(Resource res) { this.res = res; } public void run() { while(true) { try { res.out(); } catch (InterruptedException e) { } } }} 8、线程的其他要点：
线程的优先级、线程的停止；守护线程