Зміст

• Порівняльна діаграма
• Визначення класу нитки
• Визначення інтерфейсу, що працює
• Ключові відмінності між темою та програмою на Java
• Висновок:

Нитку можна визначити двома способами. По-перше, від розширення класу Thread що вже реалізував інтерфейс Runnable. По-друге, безпосередньо реалізація інтерфейсу Runnable. Коли ви визначаєте потік шляхом розширення класу Thread, вам слід перекрити метод run () у класі Thread. Коли ви визначаєте потік, що реалізує інтерфейс Runnable, ви повинні реалізувати єдиний метод run () інтерфейсу Runnable. Основна відмінність між Thread і Runnable полягає в тому, що кожен потік, визначений розширенням класу Thread, створює унікальний об'єкт і асоціюється з цим об'єктом. З іншого боку, кожен потік, визначений реалізацією інтерфейсу Runnable, поділяє один і той же об'єкт.

Зауважимо деякі інші відмінності між Thread і Runnable за допомогою таблиці порівняння, показаної нижче:

1. Порівняльна діаграма
2. Визначення
3. Ключові відмінності
4. Висновок

Порівняльна діаграма

Основа для порівняння	Нитка	Виконується
Основні	Кожна нитка створює унікальний об’єкт і з ним асоціюється.	Кілька ниток поділяють однакові об’єкти.
Пам'ять	Оскільки кожен потік створює унікальний об'єкт, потрібно більше пам’яті.	Оскільки декілька потоків поділяють один і той же об'єкт, використовується менше пам'яті.
Розширення	У Java багаторазове успадкування не дозволено, отже, після того, як клас розширює клас Thread, він не може поширювати жоден інший клас.	Якщо клас визначає потік, що реалізує інтерфейс Runnable, він має шанс розширити один клас.
Використовуйте	Користувач повинен розширити клас потоку, лише якщо він хоче замінити інші методи класу Thread.	Якщо ви хочете лише спеціалізувати метод запуску, то реалізація Runnable - кращий варіант.
Зчеплення	Розширення класу Thread вводить туге з'єднання, оскільки клас містить код класу Thread, а також завдання, призначене для потоку	Реалізація інтерфейсу Runnable вводить зв'язане з'єднання, оскільки код теми є окремою формою завдання теми.

Визначення класу нитки

Нитка це клас в java.lang пакет. Клас Thread поширюється на Об'єкт клас, і він реалізує Виконується інтерфейси. Клас "Нитка" має конструктори та методи створення та роботи над потоком. Коли ми створюємо декілька потоків, кожен потік створює унікальний об’єкт і асоціюється з цим об’єктом. Якщо ви створюєте потік, що розширює клас Thread, далі ви не можете розширити жоден інший клас, оскільки java не підтримує багатократне успадкування. Отже, вам слід вибрати розширення класу Thread лише тоді, коли ви також хочете замінити деякі інші методи класу Thread. Давайте подивимось приклад створення теми, що розширює клас Thread.

/ * Визначення потоку * / Клас Mythread розширює Thread {/ * завдання потоку * / public void run () {for (int i = 0; i <10; i ++) {System.Out.ln ("Нитка дитини" ); }} Class mainThread {/ * завдання головної нитки * / public static void main (String args) {Mythread mt = new Mythread (); / * головна нитка створила дочірню нитку * / mt.start (); for (int i = 0; i <10; i ++) {System.Out. ("Основна нитка"); }}} / * Вихід * / Основна нитка Основна нитка Основна нитка Основна нитка Дитяча нитка Дитяча нитка Дитяча нитка Дитяча нитка Дитяча нитка Основна нитка Дитяча нитка Основна нитка Основна нитка Дитяча нитка Стрічка дитини Основна нитка Основна нитка Стінка дитини Нитка головна нитка

У наведеному вище коді я створюю клас Mythread, який розширює клас Thread і замінює метод запуску класу Thread. У класі, що містить основний метод, я створю об’єкт потоку (mt) класу Mythread і за допомогою об’єкта потоку викликав метод start (). Метод запуску запускає виконання потоку і одночасно JVM викликає метод запуску потоку. Тепер у програмі є дві нитки: одна головна нитка та друга дочірня нитка, створена основною ниткою. Виконання обох потоків відбувається одночасно, але, точний вихід не можна робити.

Визначення інтерфейсу, що працює

Виконується є інтерфейсом в java.lang пакет. Реалізуючи інтерфейс Runnable, ми можемо визначити потік. Інтерфейс для запуску має єдиний метод run (), який реалізований класом, який реалізує інтерфейс Runnable. Коли ви вирішите визначити потік, що реалізує інтерфейс Runnable, у вас все ще є вибір для розширення будь-якого іншого класу. Коли ви створюєте кілька потоків, впроваджуючи інтерфейс Runnable, кожен потік має один і той же екземпляр, що може виконуватися. давайте навчимося визначати потік за допомогою інтерфейсу Runnable.

/ * Визначення потоку * / Клас Runnablethread реалізує Runnable {/ * завдання потоку * / public void run () {for (int i = 0; i <10; i ++) {System.Out.ln ("Дочірня нитка" ); }} Class mainThread {/ * завдання головної нитки * / public static void main (String args) {Mythread rt = new Mythread (); / * основний потік створив об'єкт, що виконується * / Thread t = new Thread (rt); / * головний потік створює дочірню нитку і передає об'єкт, що виконується * / t.start (); for (int i = 0; i <10; i ++) {System.Out. ("Основна нитка"); }}} / * Вихід * / Основна нитка Основна нитка Основна нитка Основна нитка Дитяча нитка Дитяча нитка Дитяча нитка Дитяча нитка Дитяча нитка Основна нитка Дитяча нитка Основна нитка Основна нитка Дитяча нитка Стрічка дитини Основна нитка Основна нитка Стінка дитини Нитка головна нитка

У наведеному вище коді я створив клас Runnablethread класу, який реалізує інтерфейс Runnable і визначає завдання потоку, реалізуючи метод run () інтерфейсу Runnable. Тоді я створюю основну нитку класу, що містить основний метод. Всередині основного методу я оголосив об'єкт, який може бути запущений класу Runnablethread і передав цей об'єкт конструктору теми, оголошуючи нитку. Таким чином я зв'язав об'єкт потоку (t) з об'єктом, який можна виконати (rt). Потім об'єкт потоку викликає метод запуску потоку, який додатково викликає метод запуску класу Runnablethread. Якби я не пов'язував запущений об'єкт з об'єктом Thread, тоді метод запуску потоків викликав би метод запуску класу Thread. Тепер, знову ж таки, у коді є два потоки, головний потік і основний потік створюють дочірній потік, обидва виконуються одночасно, але точний вихід ніколи не може бути зроблений.

Ключові відмінності між темою та програмою на Java

1. Кожен потік, створений розширенням класу Thread, створює для нього унікальний об’єкт і асоціюється з цим об’єктом. З іншого боку, кожен потік, створений реалізацією інтерфейсу Runnable, має один і той же екземпляр, що може виконуватися.
2. Оскільки кожен потік асоціюється з унікальним об'єктом при створенні розширенням класу Thread, потрібно більше пам’яті. З іншого боку, кожен потік, створений реалізацією інтерфейсу Runnable, ділиться тим самим об'єктним простором, отже, йому потрібно менше пам’яті.
3. Якщо ви продовжите клас Thread, то далі, ви можете успадкувати будь-який інший клас, оскільки Java не допускає багатократного успадкування, тоді як, впроваджуючи Runnable, все ще надається шанс успадкувати будь-який інший клас.
4. Потрібно розширити клас Thread, лише якщо він повинен перекрити або спеціалізувати деякі інші методи класу Thread. Ви повинні реалізувати інтерфейс Runnable, якщо ви хочете лише спеціалізуватися лише на методі запуску.
5. Розширення класу Thread вводить тісний зв'язок у код, оскільки код Thread та завдання потоку міститься в тому самому класі. З іншого боку, інтерфейс реалізації Runnable інтерфейсу вводить вільне з'єднання в код, оскільки код потоку відокремлюється від завдання, призначеного для потоку.

Висновок:

Переважно реалізувати інтерфейс Runnable замість розширення класу Thread. Оскільки реалізація Runnable робить ваш код слабо пов'язаним, оскільки код потоку відрізняється від класу, який присвоює завдання потоку. Це вимагає менше пам'яті, а також дозволяє класі успадкувати будь-який інший клас.