* 方法一(继承线程类): * 1.继承线程Thread类 * 2.重写run()方法------>将业务逻辑写在这里 * 3.new一个子类对象 * 4.使用子类线程用start方法
//创建一个类继承Thread
class MyThread extends Thread{
// 重写Thread里的run方法
@Override
public void run()
{
// run方法里面写业务逻辑
System.out.println("我是线程1");
}
}
public class Thread01 {
public static void main(String[] args) {
// new一个myThread子类对象
MyThread myThread=new MyThread();
// 使用线程
myThread.start();
System.out.println("我是线程2");
}
}
二、用实现Runnable方法创建线程
* 1.创建一个实现Runnable接口类 * 2.重写Runnable中的run()方法 * 3.new一个Runnable子对象 * 4.将new的子对象作为参数传入Thread类的构造器 * 5.通过Thread的start()方法启动线程
//创建一个实现Runnable接口类
class MyRunnable implements Runnable{
// 重写Runnable中的run()方法
@Override
public void run() {
System.out.println("mojo");
}
}
public class RunnableThread {
public static void main(String[] args) {
// new一个Runnable子对象
MyRunnable myRunnable=new MyRunnable();
// 将new的子对象作为参数传入Thread类的构造器
Thread thread=new Thread(myRunnable);
// 通过Thread的start()方法启动线程
thread.start();
System.out.println("大写Mojo");
}
}
三、线程的同步有两种
1.Synchronized
直接在方法上用synchronized,然后在线程的run()方法上用
public synchronized void TestReentrantLock()
{
int num=100;
while (true){
if(num>0)
{
System.out.println(num);
num--;
}
}
}
2.ReentrantLock
class MyRunnableDemo implements Runnable{
RunnableThreadDemo runnableThreadDemo=new RunnableThreadDemo();
@Override
public void run() {
runnableThreadDemo.TestReentrantLock();
}
}
public class RunnableThreadDemo {
public static void main(String[] args) {
// 注意这里只new了一次Runnable对象
MyRunnableDemo myRunnableDemo=new MyRunnableDemo();
// 启动的三个线程都为myRunnableDemo的对象类
Thread thread1=new Thread(myRunnableDemo);
Thread thread2=new Thread(myRunnableDemo);
Thread thread3=new Thread(myRunnableDemo);
thread1.start();
thread2.start();
thread3.start();
}
// 创建锁
public Lock lock=new ReentrantLock();
public void TestReentrantLock()
{
// 加锁
lock.lock();
int num=100;
while (true){
if(num>0)
{
System.out.println(num);
num--;
}
}
}
}



