We Keep Coding

Creating a thread is not working

I am trying to implement a thread into a project I am working on and I am not sure where i am going wrong.
package Project;
public class Launch{
public static void main(String[] args) {
Threads thread = new Threads();
thread.start();
}
}
class Threads implements Runnable{
static FruitSpawn spawn = new FruitSpawn();
public void run(){
spawn.spawnFruit();
}
}
The program is asking me to create a method called start() in Threads instead of stating the thread. Where am i going wrong in creating the thread? I am working in Java thanks.

Threads is just implementing Runnable not extending Thread so you can't call start() on it.
Do:
Thread t =new Thread(new Threads());
t.start();

You create a Thread, giving it your Runnable to run and then start it.
class Threads implements Runnable {
static FruitSpawn spawn = new FruitSpawn();
public void run() {
spawn.spawnFruit();
}
}
public void test() {
Threads spawner = new Threads();
Thread t = new Thread(spawner);
t.start();
}

you have to pass your Runnable to Thread class while initialization.
public class Launch{
public static void main(String[] args) {
Runnable runabl = new Threads();
Threads thread = new Threads(runabl);
thread.start();
}
}
class Threads implements Runnable{
static FruitSpawn spawn = new FruitSpawn();
public void run(){
spawn.spawnFruit();
}
}

Threads is implementing Runnable interface, and not extending Thread class. So, either you should
(a) Let Threads class implement Runnable and use
new Thread(new Threads()).start();
or
(b) Enhance Threads class to extend Thread class and not implement Runnable interface.

You can do some thing like:
Threads thread = new Threads(this);
thread.start();
thread.start() creates a new thread and have its own execution scenario. thread.start() calls the run method asyc.when come to running state.

Majorly speaking Thread Class has 4-flavour(other too but rarely used) of Constructor likewise,
1. Thread(),
2. Thread(String threadName),
3. Thread(Runnable target),
4. Thread(Runnable target, String threadName).
Now you have Threads class which implements Runnable Interface.
So Object of Threads class called Runnable type Object.
Now you have to pass that Threads class Object into 3rd flavor of Thread Class constructor.
so do following changes in your code and enjoy !!
public class Launch{
public static void main(String[] args) {
Threads runnableObject= new Threads();
Thread t = new Thread(runnableObject); // among of above listed 3rd flavor of Thread class constructor.
t.start(); // start thread which will call run() of Threads Class.
}
}

Getting the method that creates runnable from thread which runs the runnable

Suppose I have a custom Thread class which is responsible for running runnables
public class MyThread extends Thread{
public MyThread(Runnable r) {
super(r);
}
#Override
public void run() {
super.run(); // Can I put something here to get info about where the runnable is submitted from?
}
}
Then in some method, I submit the runnable
public void someMethod() {
new MyThread(new Runnable() {
#Override
public void run() {
System.out.println("Blah");
}
});
}
Suppose I have no control over someMethod, can I modify MyThread such that whenever a runnable is submitted to MyThread, I can get info about someMethod (e.g. method name someMethod, class name) ?
Edit
In fact the original question is part of my problem.
I am providing a ThreadFactory that can be used by a threadpool (ExecutorService).
public class MyThreadFactory implements ThreadFactory {
#Override
public Thread newThread(Runnable r) {
return new MyThread(r);
}
}
User can create a threadpool with MyThreadFactory
ExecutorService pool = Executors.newCachedThreadPool(new MyThreadFactory());
By calling pool.execute(runnable), a instance of MyThread will be created to perform the task specified by runnable. It is possible that the thread will be reused by multiple runnables. So I would like to retrieve Method and Class info in the public void run() method of MyThread. Since runnable is stored in a private field in the base Thread class, I cannot use a modified version of the solution provided by Laerte like:
#Override
public void run() {
super.run();
// Not working, Since MyThread cannot access private field target of Thread class
Method m = target.getClass().getEnclosingMethod();
System.out.println(m.toString());
}
Can I still obtain Method and Class about where the runnable is instantiated , at the moment public void run() is invoked?

To know things related to calling methods, class names, and so on, you should use reflection.
In your case, you should modify your code like this.
class MyThread extends Thread{
public MyThread(Runnable r) {
super(r);
Method m = r.getClass().getEnclosingMethod();
System.out.println(m.toString());
}
#Override
public void run() {
super.run();
}
}
The Method class will have the method reference. Using this call Method m = r.getClass().getEnclosingMethod();, you will receive the method that is enclosing the Runnable object. In your case, oneMethod.
That's the idea. Tell me if it helps.

implementing thread using runnable interface in java

Why we have to create an instance of a class and attach it to the newly created thread object even if both are in the same class?
import java.io.*;
class thread1 implements Runnable{
public void run(){
System.out.println("thread started");
}
public static void main(String args[]) throws Exception{
Thread t1=new Thread(new thread1());
t1.start();
}
}

You don't have to create a Runnable to perform custom code within a new Thread. It's also possible to create a subclass of thread directly.
public class WorkerThread extends Thread{
#Override
public void run() {
// TODO Auto-generated method stub
super.run();
// DO SOMETHING
}
}
public class MainClass {
public static void main(String[] args){
new WorkerThread().start();
MainClass mc = new MainClass();
mc.startThread();
}
private void startThread(){
Thread t = new WorkerThread();
t.start();
}
}

I think you have two questions in one:
1.) How to work with a Thread in Java? The answer of Fizer Khan is an example of this.
2.) How do static methods work in java? If you have a static method you are, in a maner of speaking, on a "static layer". You have no "this" reference because there is not object on this layer. Only if you create an instance you can access instance fields and non static methods on this object.
If you add a second static method, you can do the same stuff as in your main method, because both are static. This is rudementary look at this question: https://stackoverflow.com/questions/18402564/how-do-static-methods-work
pulblic class Thread1 implements Runnable{ //name should be upper case
public void run(){
System.out.println("thread started");
}
public static void main(String args[]) throws Exception{ //static method
Thread t1=new Thread(new Thread1()); //t1 is a local reference to an object on the heap - no specil magic here
t1.start(); //call to an "instance" method, can only be performed on an object.
}

There are two ways to write threads.
public class ThreadX implements Runnable {
public void run() {
//Code
}
}
/* with a "new Thread(new ThreadX()).start()" call */
public class ThreadY extends Thread {
public ThreadY() {
super("ThreadY");
}
public void run() {
//Code
}
}
/* with a "new ThreadY().start()" call */
public class MainClass {
private Thread threadX = new Thread(new ThreadX());
private Thread threadY = new ThreadY();
public static void main(String[] args){
// Call threads
threadX.start();
threadY.start();
// some more threads
new Thread(new ThreadX()).start();
new ThreadY().start();
}
}
When you extends Threads, You usually extend a class to add or modify functionality. So, if you don't want to overwrite any Thread behavior, then use Runnable.

Java Thread Creation

I am trying to create a thread using runnable method .The code is below
public class NewClass implements Runnable{
public static void main(String[] agrg){
NewClass n =new NewClass();
n.start();
}
void start(){
Thread th=new Thread();
th.start();
}
#Override
public void run() {
System.out.println("Thread");
}
}
In this override method run should me call ,but it is not happening

Your run() method is belong to NewClass which is not a Thread, it's a worker.
So, no body going to call run() method of NewClass
In java, when you are creating a worker by implementing Runnable, you should override the run() method only. And pass an instance of this worker to a Thread, like
new Thread(new NewClass()).start();
So you can do the following
public class NewClass implements Runnable{
public static void main(String[] agrg){
NewClass n =new NewClass();
n.start();
}
void start(){
Thread th=new Thread(this);
th.start();
}
#Override
public void run() {
System.out.println("Thread");
}
}

You need to pass the Runnable instance to the Thread class constructor.
In your case, replace Thread th=new Thread(); with Thread th=new Thread(new NewClass()).
When you create a Thread class instance using Thread th=new Thread(); the default implementation of the Thread.run() method is invoked (which does nothing).
Thus, you need override the run() method in your implementing class (NewClass in your case) which you have done correctly. But you also need to specify the implementing class instance to the Thread class constructor using Thread th=new Thread(new NewClass())

You are starting a new Thread, but that thread isn't actually doing anything. The new thread has no connection whatsoever to the class it is started from or the code that class contains.
When you implement a Runnable, you usually perform it by creating a thread with that runnable as an argument.
Runnable myRunnable = new NewClass();
Thread myThread = new Thread( myRunnable );`
myThread.start(); // will execute myRunnable.run() in background
or by using an Executor.
Executor myExecutor = new SheduledThreadPoolExecutor(NUM_OF_PARALLEL_THREADS);
Runnable myRunnable = new NewClass();
myExecutor.execute(myRunnable); // will execute myRunnable.run() in background as soon as one of the parralel threads is available

Your Thread class is a separate class from your main class.
public class ThreadClass implements Runnable {
#Override
public void run() {
System.out.println("Thread");
}
}
public class MainClass {
public static void main(String[] agrg) {
ThreadClass t = new ThreadClass();
Thread th = new Thread(t);
th.start();
}
}

As mentioned earlier, no one is there to run your "run" method. You can extend Thread and can ask the run method to do the work just by starting the Thread
public class NewClass extends Thread{
public static void main(String[] agrg){
NewClass n =new NewClass();
n.start();
}
#Override
public void run() {
System.out.println("Thread");
}
}

Callback from new thread to class from which thread was initiated

I have a class from which I am calling a new thread.
public class MainClass{
private void cleardata() {
// do something on a separate thread
new Thread(new Runnable() {
#Override
public void run() {
//Do Something
//After this I would like to notify my MainClass that some thing has been done and pass a value.
}
}
}
private void callbackFunc(int a){
// Do something based on value of a
}
}
I have a function in my MainClass. But how do i call this function from my new thread, so as to receive a callback.
Thanks.

You should just be able to call the method in MainClass by its name just as if you were calling from directly inside MainClass itself (as opposed to from the inner class).
If a method name you want to call happens to conflict with one that your inner class has inherited from Object then you can prefix the call with MainClass.this, e.g. MainClass.this.toString() calls toString on MainClass, whereas just toString() calls it on the inner class instance.

In such a case pass the instance of MainClass to the thread class ((during creation)) so that it can call method on it. Having inner class as suggested by others is also a good option.
Something similar-
class MainClass {
private void cleardata() {
new Thread(new MyThread(this)).start();
}
}
class MyThread implements Runnable {
private MainClass mc;
MyThread(MainClass mc) {
this.mc = mc;
}
public void run() {
// do something
// mc.someMethod();
}
}

public class MainClass{
private void cleardata() {
// do something on a separate thread
new Thread(new Runnable() {
#Override
public void run() {
callBackFunc(result);
}
}
}
private void callBackFunc(int a) {
}
}

Just do it:
public class MainClass{
private void cleardata() {
// do something on a separate thread
new Thread(new Runnable() {
#Override
public void run() {
//Do Something
notifyTheClass("a parameter");
}
}
private void notifyTheClass(String aParam) {
//..do something else
}
}
}
But it is not related to threads, this is about inner classes. If you want the main thread to wait until the new thread is finishes, use Futures for a result. Or use some other multithreading primitives.