Witam mialem do napisania pare programów , czy mógłby mi ktoś je sprawdzić czy są dobrze napisane?
Z góry dziekuję.
1)Zaimplementuj klasę wątku ze zmienną statyczną "wspólna" obiektem synchronizującym
oraz dwiema metodami prywatnymi w których odbywają się obliczenia na zmiennej "wspolna"
, dokonać blokady wspólnych zasobów na czas obliczeń w metodzie run(), należy wywołać obie metody składowe klasy. Utworzyć i uruchomić dwa wątki.
public class MyThread extends Thread{
public static Integer common = 0;
Object lock;
public MyThread(Object lock){
this.lock = lock;
}
public void run(){
while(common < 100){
metoda1();
metoda2();
}
}
private void metoda1(){
synchronized(lock){
common ++;
System.out.println(common);
}
}
private void metoda2(){
synchronized(lock){
common ++;
System.out.println(common);
}
}
public static void main(String[] args){
Object MyObj = new Object();
MyThread T1 = new MyThread(MyObj);
T1.start();
}
}
2)Zaimplementować klasę dziedziczną po klasie Thread i przesłać metodę run(). W metodzie run() powinna się znajdować nieskończona pętla, w której wypisywany jest dowolny komunikat z nazwą wątku. Klasa musi umożliwiać nadanie dowolnej nazwy wątkowi. W metodzie main powinny być utworzone 3 wątki o nazwach nadanych w konstruktorze i uruchomione przy pomocy odpowiedniej metody.
public class MyThread extends Thread{
private String name;
MyThread(String name){
this.name = name;
}
public void run(){
for(;;){
System.out.println("Thread name: " + name);
}
}
public static void main(String[] args){
MyThread T1 = new MyThread("pierwszy");
MyThread T2 = new MyThread("drugi");
MyThread T3 = new MyThread("trzeci");
T1.start();
T2.start();
T3.start();
}
}
3)Zaimplementuj odpowiednią klasę z 3 metodami synchronizującymi ('włóż', 'wyciąg', 'sprawdź') zmienną statyczną 'zawartość' i zmienną boolowską określającą czy pudełko jest pełne czy nie. Metoda 'włóż' pozwala na włożenie czegoś do pudełka, 'wyciąg' do wyciągnięcia a 'sprawdź' do sprawdzenia.
```java
public class MyThread extends Thread{
Boolean box = new Boolean("false");
static String zawartosc;
MyThread(Boolean box){
this.box = box;
}
public synchronized void wloz(String content){
if(sprawdz()){
yield();
}
box = true;
this.zawartosc = content;
}
public synchronized void wyciag(){
if(!sprawdz()){
yield();
}
box = false;
this.zawartosc = "";
}
public synchronized boolean sprawdz(){
return box;
}
public static void main(String[] args){
Boolean box = new Boolean("false");
MyThread T1 = new MyThread(box);
MyThread T2 = new MyThread(box);
for(;;){
if(!T1.sprawdz()){
T1.wloz("content");
yield;
}
if(T2.sprawdz()){
T2.wyciag();
yield;
}
}
}
}
4)Stwórz klasę implementującą interfejs Runable() i przysłaniającą metodę run(), w run() powinna być pętla nieskończona w każdej iteracj powinno być wypisane czy nie nastąpiło przerwanie aktualnej iteracji. W przypadku przerwania wyświetlany będzie komunikat o przerwaniu. W metodzie main() utworzyć 4 wątki, uruchomić i wywołać dla nich przerwanie.
public class MyThread implements Runnable{
public void run(){
while(!Thread.currentThread().isInterrupted()){
System.out.println("iteracja nie zostala przerwana");
}
System.out.println("iteracja zostala przerwana");
}
public static void main(String[] args){
Thread T1 = new Thread(new MyThread());
Thread T2 = new Thread(new MyThread());
Thread T3 = new Thread(new MyThread());
Thread T4 = new Thread(new MyThread());
T1.start();
T2.start();
T3.start();
T4.start();
T1.interrupt();
T2.interrupt();
T3.interrupt();
T4.interrupt();
}
}
5)Zaimplementować klasę dziedziczącą po klasie Thread i przesłonić metodę run(). W metodzie run()powinna się znajdować nieskończona pętla, w której wykonywane powinny być jakieś obliczenia, następnie jeśli wystąpiło przerwanie to metoda run() powinna się zakończyć jeśli nie to czas procesora powinien być przekazany innym wątkom.
class MyThread extends Thread {
private static float liczba = 10.0;
private static String key = new String();
public MyThread(String name) {
super(name);
}
@override
public void run() {
for(;;) synchronized(key) {
liczba = liczba +1;
if(liczba%2 == 0) liczba = liczba/2;
else liczba = liczba*2;
if(isInterrupted()) {
return;
} else {
yield();
}
}
}
}
6)Zaimplementować klasę z trzema metodami synchronizowanymi ("dodaj", "odejmij" i "wypisz") i zmienną "liczba" Metody odpowiadają za konkretne operacje na zmiennej statycznej np. metoda "dodaj" dodaje do zmiennej "liczba" liczbę podaną jako parametr.
```java
class MyThread extends Thread {
private static int zmienna = 10;
public MyThread(String name) {
super(name);
}
@override
public void run() {
...
}
public static synchronized dodaj () {
int temp = 1;
zmienna = zmienna + temp;
}
public static synchronized odejmij () {
int temp = 1;
zmienna = zmienna - temp;
}
public static synchronized wypisz () {
System.out.println("zmienna = "+zmienna);
}
}
7)Zaimplementować klasę implementującą interfejs Runnable i przesłonić metodę run(). W metodzie run() powinna się znajdować pętla zliczająca do 2000, w każdej iteracji wypisywany zostać komunikat z informacją o numerze aktualnej iteracji i nazwie wątku. W metodzie main() należy utworzyć 3 wątki i je uruchomić.
class MyThread implements Runnable {
private String name;
public MyThread(String name) {
this.name = name;
}
@override
public void run() {
for(int i = 0; i < 2000; i++)
System.out.println(name + i);
}
public void main () {
t1 = new MyThread("jeden");
t2 = new MyThread("dwa");
t3 = new MyThread("trzy");
(new Thread(t1)).start();
(new Thread(t2)).start();
(new Thread(t3)).start();
}
}
8)Zaimplementować klasę wątku ze zmienną statyczną "liczba" i obiektem synchronizującym. W metodzie run() należy wykonywać w pętli zwiększanie "liczby" o 37 i wypisywać ją w każdej iteracji. Należy dokonać blokady wspólnych zasobów na czas operacji. Utworzyć i uruchomić trzy wątki.
```java
class MyThread extends Thread {
private static int liczba = 0;
private static Object key = new Object();
public MyThread(String name) {
super(name);
}
@override
public void run() {
for(;;) synchronized(key) {
liczba += 37;
System.out.println(name + liczba;
}
}
public void main () {
(new MyThread("jeden")).start();
(new MyThread("dwa")).start();
(new MyThread("trzy")).start();
}
}