A:进程：
进程指正在运行的程序。确切的来说，当一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能。
B:线程：
线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
C:简而言之：
一个程序运行后至少有一个进程，一个进程中可以包含多个线程
线程实现
实现的两种方式
继承Thread
public class MyThread extends Thread{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(getName()+":"+i);
}
}
}
测试类
public class MyThread02 extends Thread {
@Override
public void run() {
MyThread t=new MyThread();//直接创建对象就能创建一个线程
t.start();
}
}
实现Runnable
public class MyThreadImp implements Runnable{
int num;
public MyThreadImp(int num){
this.num=num;
}
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName()+num++);
}
}
}
测试类
public class Test01 {
public static void main(String[] args) {
MyThreadImp mt=new MyThreadImp(10);
Thread t=new Thread(mt);
t.setName("张三");
t.start();
Thread t1=new Thread(mt);
t1.setName("李四");
t1.start();
}
}
多线程安全问题
线程的安全性==数据的安全性
①是否存在多线程
②是否有共享数据
③是否有多条语句执行共享数据
解决办法 synchronized同步锁
eg:
public class MyThread implements Runnable {
int tickets;
public MyThread(int tickets) {
this.tickets = tickets;
}
Object o = new Object();
@Override
public void run() {
while (true) {
synchronized (o) {
if (tickets > 1) {
System.out.println(Thread.currentThread().getName() + "-"
+ tickets--);
}
}
}
}
}
测试类
MyThread mt=new MyThread(100);
Thread t=new Thread(mt);
t.setName("窗口1");
Thread t2=new Thread(mt);
t2.setName("窗口2");
Thread t3=new Thread(mt);
t3.setName("窗口3");
t.start();
t2.start();
t3.start();
如果不给线程加锁 则会产生数据乱掉，可能会产生-1；结果我们不可预测。
在方法中给加锁，另一种方法则是给方法加锁eg:
public class MyThread01 implements Runnable{
static int tickets=100;
public MyThread01(int tickets) {
this.tickets = tickets;
}
@Override
public void run() {
while (true) {
method01();
}
}
private synchronized void method01() {
if (tickets >= 1) {
System.out.println(Thread.currentThread().getName() + "-"
+ tickets--);
}
}
}
抢红包案列：
public class MyThread implements Runnable {
int money;
int count;
public MyThread(int money, int count) {
this.money = money;
this.count = count;
}
@Override
public void run() {
// 产生一个随机数
method();
}
private synchronized void method() {
if (count > 1 && money != 0) {
Random r = new Random();
double d = (r.nextInt(money) + 1);
money -= d;
System.out.println(Thread.currentThread().getName() + ":" + d);
count--;
} else {
System.out.println(Thread.currentThread().getName() + ":"
+ money);
}
}
}
测试类
public class Hongbao {
public static void main(String[] args) {
MyThread mt=new MyThread(10,3);
Thread t=new Thread(mt);
t.setName("张三");
t.start();
t.setPriority(10);
Thread t1=new Thread(mt);
t1.setName("李四");
t1.start();
Thread t2=new Thread(mt);
t2.setName("李");
t2.start();
}
}
生产消费者模式：
解释了多线程唤醒机制(notify()是Object中的方法)
使用多线程中的案列
产品 由于只是做测试使用 没有写全
public class Student {
String name;
int age;
boolean flag;
}
生产者 如果消费者没有消费产品 则进行等待 ，只有消费了生产者才会进行生产
public class StThread implements Runnable {
private Student s;
public StThread(Student s) {
this.s = s;
}
int x;
@Override
public void run() {
while (true) {
synchronized (s) {
if (s.flag) {//如果flag=true;则说明已经有对象了 还没有消费，则进行等待
try {
s.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}// 等待
}
if (x % 2 != 0) {
s.name = "赵云";
s.age = 44;
} else {
s.name = "张飞";
s.age = 22;
}
x++;
s.flag=true;//修改标记
s.notify();//唤醒
}
}
}
}
消费者 如果消费者没有东西消费 则会进行等待 有了东西，才会进行消费
public class GtThread implements Runnable {
private Student s;
public GtThread(Student s) {
this.s = s;
}
@Override
public void run() {
while (true) {//保证一直在等待中
synchronized (s) {
if (!s.flag) {//flag=false则进行等待 等待学生对象的产生
try {
s.wait();//线程等待
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(s.name + ":" + s.age);
s.flag=false;
s.notify();
}
}
}
}
测试类
public class Test {
public static void main(String[] args) {
Student s=new Student();
StThread st=new StThread(s);
GtThread gt=new GtThread(s);
Thread t1=new Thread(st);
Thread t2=new Thread(gt);
t1.start();
t2.start();
}
}
输出结果
输出结果: 赵云:44 张飞:22 赵云:44 张飞:22 赵云:44 张飞:22 赵云:44 .......一直交替循环下去
线程的生命周期
